kizlo 0.9.0 → 0.10.0

package/dist/cli/commands/create.js

@@ -1,9 +1,8 @@
-import { dockerAvailable } from "../wp/docker.js";
-import { availablePackageManagers, detectInvokingPackageManager, ensureGitignored, frameworkCreateArgs, getVersion, installArgs, runCommandAsync, runCommandCaptured } from "../utils.js";
+import { availablePackageManagers, detectInvokingPackageManager, ensureGitignored, frameworkCreateArgs, installArgs, runCommandAsync, runCommandCaptured } from "../utils.js";
 import { getPreset } from "../presets/index.js";
 import { fetchTemplate } from "../presets/source.js";
-import { adaptFile, changesFor, fileEntries, isExample, patchEntries, readManifest } from "../presets/template.js";
-import { collectConnectionInteractively, nextStepsLines, orCancel, pickAppPort, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
+import { adaptFile, changesFor, fileEntries, isExample, minCliError, patchEntries, readManifest, resolveDependencies } from "../presets/template.js";
+import { collectConnectionInteractively, nextStepsLines, orCancel, pickAppPort, readEnvExample, resolveEnvKeys, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
 import { applyLayoutPatches, buildScaffoldContext, kizloConfigTemplate, reportScaffold, scaffoldFile, writeGeneratedContract } from "./_wiring.js";
 import z from "zod/v4";
 import path from "node:path";
@@ -29,16 +28,23 @@ const PACKAGE_MANAGERS = [
 	"bun"
 ];
 /**
-* Pin the `kizlo` dependency in the freshly bootstrapped `package.json`. The template is
-* authoritative for the version (`kizloVersion` in its manifest, stamped at release), falling back to
-* the running CLI's version in-repo before the first stamp. The dependency is only recorded, not
-* installed — the getting-started note tells the user to run install.
+* Pin Kizlo's dependencies in the freshly bootstrapped `package.json`. The template is authoritative
+* for the versions (its manifest's `dependencies`/`devDependencies`, stamped at release), falling back
+* to the running CLI's version for `kizlo` in-repo before the first stamp. The deps are only recorded,
+* not installed — the getting-started note tells the user to run install.
 */
-function recordKizloDependency(dir, manifest) {
+function recordDependencies(dir, manifest) {
 	const pkgPath = path.join(dir, "package.json");
 	const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-	pkg.dependencies ??= {};
-	pkg.dependencies.kizlo = manifest.kizloVersion ?? `^${getVersion()}`;
+	const { dependencies, devDependencies } = resolveDependencies(manifest);
+	pkg.dependencies = {
+		...pkg.dependencies,
+		...dependencies
+	};
+	if (Object.keys(devDependencies).length) pkg.devDependencies = {
+		...pkg.devDependencies,
+		...devDependencies
+	};
 	fs.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, "	")}\n`);
 }
 /**
@@ -59,7 +65,7 @@ function bootstrapArgs(manifest, pm, name) {
 * tsconfig, the root layout); this drives the manifest — the same engine `init` uses — to record the
 * `kizlo` dependency, write `kizlo.config.ts`, scaffold the manifest's files (the `base` plumbing and
 * the `create` layout/styles always, the `example`-flagged demo pages only when `includeExamples`),
-* seed the generated contract, and ignore `.env`. On a fresh app Kizlo owns the layout, so `create`
+* seed the generated contract, and ignore `.env` and the `.kizlo/` working dir (which holds the local WordPress install). On a fresh app Kizlo owns the layout, so `create`
 * writes it whole (already SEO-wired) rather than patching — `applyLayoutPatches` runs over `create`'s
 * patches, which are none today. The target directory layout comes straight from the manifest's
 * conventions, which the bootstrap flags are chosen to match, so files land where they expect. Fresh
@@ -73,12 +79,12 @@ async function applyManifestWiring(dir, templateDir, manifest, opts) {
 		alias,
 		clientUrl: void 0
 	});
-	recordKizloDependency(dir, manifest);
+	recordDependencies(dir, manifest);
 	const changes = changesFor(manifest, "create").filter((change) => opts.includeExamples || !isExample(change));
 	const files = [{
 		label: "Kizlo config",
 		relPath: "kizlo.config.ts",
-		contents: kizloConfigTemplate(kizloDir, alias, opts.devPath)
+		contents: kizloConfigTemplate(kizloDir, alias, opts.localDev)
 	}, ...fileEntries(changes).map((entry) => adaptFile(templateDir, entry, manifest.conventions, scaffold))];
 	for (const file of files) reportScaffold(file, await scaffoldFile(dir, file, {
 		force: true,
@@ -86,6 +92,7 @@ async function applyManifestWiring(dir, templateDir, manifest, opts) {
 	}), false);
 	writeGeneratedContract(dir, path.join(kizloDir, "server"));
 	ensureGitignored(dir, ".env");
+	ensureGitignored(dir, ".kizlo/");
 	applyLayoutPatches(dir, patchEntries(changes), manifest.conventions, scaffold);
 }
 const create = defineCommand({
@@ -156,16 +163,12 @@ const create = defineCommand({
 			})),
 			initialValue: defaultPm
 		}));
+		const conn = await collectConnectionInteractively(preset, { baseUrl: `http://localhost:${await pickAppPort()}` });
+		if (preset.apiPath && conn.baseUrl) conn.baseUrl = withApiPath(conn.baseUrl, preset.apiPath);
 		const includeExamples = orCancel(await p.confirm({
-			message: "Add example pages?",
+			message: "Add examples?",
 			initialValue: true
 		}));
-		const conn = await collectConnectionInteractively(preset, { baseUrl: `http://localhost:${await pickAppPort()}` });
-		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 fetched = await fetchTemplate(template);
 		const fail = (message) => {
 			fetched.cleanup();
@@ -173,6 +176,8 @@ const create = defineCommand({
 			process.exit(1);
 		};
 		const manifest = readManifest(fetched.dir);
+		const minErr = minCliError(manifest);
+		if (minErr) fail(minErr);
 		const bootstrap = bootstrapArgs(manifest, pm, name);
 		if (!bootstrap) {
 			fetched.cleanup();
@@ -187,10 +192,11 @@ const create = defineCommand({
 			if (scaffold.output) p.log.error(scaffold.output);
 			fail(`${preset.label} setup failed — see the output above and try again.`);
 		}
+		const exampleTemplate = readEnvExample(fetched.dir);
 		try {
 			await applyManifestWiring(dir, fetched.dir, manifest, {
-				devPath: conn.devPath,
-				includeExamples
+				includeExamples,
+				localDev: conn.mode === "local"
 			});
 		} catch (error) {
 			fail(error instanceof Error ? error.message : String(error));
@@ -208,9 +214,10 @@ const create = defineCommand({
 			if (!depsInstalled) p.log.warn(`Install them yourself: cd ${name} && ${installArgs(pm).join(" ")}`);
 		}
 		await setupLocalWordPress(dir, conn);
-		await writeEnv(dir, preset, conn, {
+		await writeEnv(dir, resolveEnvKeys(preset, manifest), conn, {
 			force: true,
-			yes: false
+			yes: false,
+			exampleTemplate
 		});
 		await syncRemote(conn);
 		p.note([

package/dist/cli/commands/dev.js

@@ -1,6 +1,6 @@
-import { createStack } from "../wp/docker.js";
-import { ensureGitignored, envGroups, groupDefault, mergeEnv, pickStackPort, withSpinner } from "../utils.js";
-import { hasDevStack, resolveDevConfig } from "../daemon/config.js";
+import { createStack, dockerHint, dockerStatus } from "../wp/docker.js";
+import { DEFAULT_ENV_KEYS, ensureGitignored, envGroups, groupDefault, mergeEnv, pickStackPort, withSpinner } from "../utils.js";
+import { resolveDevConfig, usesLocalWordPress } from "../daemon/config.js";
 import { bootstrapDev } from "../wp/dev.js";
 import { reapOrphans, registerSession, removeProjectContainers, spawnWatchdog, unregisterSession } from "../wp/session.js";
 import { syncSiteSettings } from "../wp/settings.js";
@@ -21,15 +21,13 @@ async function resolve$1(cwd) {
 	};
 }
 /**
-* The stack lifecycle subcommands (`stop`/`down`/`reset`) only act on a local WordPress
-* Docker stack. A bring-your-own-WordPress project (no `dev.path`) has no stack to manage,
-* so — rather than fall through to `resolveDevConfig`'s hard "`dev.path` is required" error —
-* print a plain note explaining there's nothing to do and exit cleanly. Returns true when a
-* local stack is configured and the caller may proceed.
+* The lifecycle subcommands (`stop`/`reset`) only act on local WordPress. A project pointing at its
+* own WordPress (no `dev.local`) has nothing to manage, so print a plain note and exit cleanly. Returns
+* true when local WordPress is configured and the caller may proceed.
 */
-async function requireDevStack(cwd) {
-	if (await hasDevStack(cwd)) return true;
-	note("No local WordPress stack is configured (`dev.path` is unset) — nothing to manage here.");
+async function requireLocalWordPress(cwd) {
+	if (await usesLocalWordPress(cwd)) return true;
+	note("This project doesn't run local WordPress — set `dev.local: true` in kizlo.config.ts to add it.");
 	return false;
 }
 /** A dim, untagged one-liner (no consola timestamp) for the clean dev output. */
@@ -39,7 +37,7 @@ function note(text) {
 }
 /**
 * 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
+* the loopback ("Local") and — when local WordPress 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).
 */
@@ -52,57 +50,56 @@ function printSummary(info) {
 	const width = Math.max(...rows.map(([label]) => label.length)) + 1;
 	const lines = ["", ...rows.map(([label, value]) => `   ${dim}- ${`${label}:`.padEnd(width)}${reset} ${cyan}${value}${reset}`)];
 	if (info.secrets) lines.push("", `   ${dim}admin login:${reset} ${info.username} / ${info.secrets.password}`, `   ${dim}save the password now — it's shown only once${reset}`);
-	else if (info.imported) lines.push("", `   ${dim}log in with your imported site's own credentials${reset}`);
 	if (info.seeded > 0) lines.push(`   ${dim}seeded ${info.seeded} fixture${info.seeded === 1 ? "" : "s"}${reset}`);
 	process.stdout.write(`${lines.join("\n")}\n`);
 }
 /**
-* Dev connection keys a fresh dev install must rewrite (the rest of `.env` is untouched). The
-* production `KIZLO_WORDPRESS_*` / `KIZLO_SITE_SECRET` keys live under their own names and are never
-* touched by `kizlo dev`, so pointing them at a real site survives booting the local stack.
+* Local-WordPress connection keys a fresh install must rewrite (the rest of `.env` is untouched). The
+* remote `KIZLO_WP_*` / `KIZLO_WP_SECRET` keys live under their own names and are never
+* touched by `kizlo dev`, so pointing them at a real site survives booting local WordPress.
 */
 const WP_ENV_KEYS = [
-	"KIZLO_DEV_WORDPRESS_URL",
-	"KIZLO_DEV_WORDPRESS_USERNAME",
-	"KIZLO_DEV_WORDPRESS_APPLICATION_PASSWORD"
+	"KIZLO_LOCAL_WP_URL",
+	"KIZLO_LOCAL_WP_USERNAME",
+	"KIZLO_LOCAL_WP_APP_PASSWORD"
 ];
 /** Read a key's value from raw `.env` content (first match, trimmed); undefined when absent or empty. */
 function readEnvValue(content, key) {
 	return content.match(new RegExp(`^\\s*${key}\\s*=\\s*(.*)$`, "m"))?.[1]?.trim() || void 0;
 }
 /**
-* The Kizlo backend URL from `.env` — the one key ending in `KIZLO_BACKEND_URL` (`KIZLO_BACKEND_URL`,
-* or a framework-prefixed `NEXT_PUBLIC_KIZLO_BACKEND_URL`). It's the handler mount the plugin delivers
+* The Kizlo backend URL from `.env` — the one key ending in `KIZLO_API_URL` (`KIZLO_API_URL`,
+* or a framework-prefixed `NEXT_PUBLIC_KIZLO_API_URL`). It's the handler mount the plugin delivers
 * webhook events to; its origin is the site's canonical URL. User-managed (init writes it), so dev
 * only reads it. Undefined before `kizlo init` has populated `.env`.
 */
 function readBaseUrl(content) {
-	return content.match(/^\s*[A-Z_]*KIZLO_BACKEND_URL\s*=\s*(.*)$/m)?.[1]?.trim() || void 0;
+	return content.match(/^\s*[A-Z_]*KIZLO_API_URL\s*=\s*(.*)$/m)?.[1]?.trim() || void 0;
 }
 /**
-* Rewrite the dev WordPress connection in `.env` after a fresh install. A reset (or first boot)
+* Rewrite the local WordPress connection in `.env` after a fresh install. A reset (or first boot)
 * wipes the database, so the previous application password — and possibly the port — no longer
 * match; without this the app keeps the stale credentials and REST auth fails. Only the three
 * connection keys are overwritten; everything else in `.env` is preserved, and the file is created
 * if absent. Gated by the caller on a minted `appPassword`, so a warm resume never churns it.
 *
-* `KIZLO_TARGET=dev` and `KIZLO_DEV_SITE_SECRET` are written too but kept out of the overwrite set, so a
-* value the user already set is preserved — booting the dev stack only fills them when absent. The
-* resolved dev secret (the existing one, or a freshly minted one) and the Kizlo server base URL are
-* returned so the caller can sync them into the plugin.
+* `KIZLO_CONNECT=local` and `KIZLO_LOCAL_WP_SECRET` are written too but kept out of the overwrite set,
+* so a value the user already set is preserved — booting local WordPress only fills them when absent.
+* The resolved local secret (the existing one, or a freshly minted one) and the Kizlo server base URL
+* are returned so the caller can sync them into the plugin.
 */
 function updateWpEnv(cfg, info) {
 	if (!info.appPassword) return void 0;
 	const envPath = join(cfg.configDir, ".env");
 	const existing = existsSync(envPath) ? readFileSync(envPath, "utf8") : "";
-	const siteSecret = readEnvValue(existing, "KIZLO_DEV_SITE_SECRET") ?? randomBytes(32).toString("hex");
+	const siteSecret = readEnvValue(existing, "KIZLO_LOCAL_WP_SECRET") ?? randomBytes(32).toString("hex");
 	const { content } = mergeEnv(existing, {
-		KIZLO_DEV_WORDPRESS_URL: info.url,
-		KIZLO_DEV_WORDPRESS_USERNAME: info.username,
-		KIZLO_DEV_WORDPRESS_APPLICATION_PASSWORD: info.appPassword,
-		KIZLO_DEV_SITE_SECRET: siteSecret,
-		KIZLO_TARGET: "dev"
-	}, new Set(WP_ENV_KEYS), envGroups("KIZLO_BACKEND_URL"));
+		KIZLO_LOCAL_WP_URL: info.url,
+		KIZLO_LOCAL_WP_USERNAME: info.username,
+		KIZLO_LOCAL_WP_APP_PASSWORD: info.appPassword,
+		KIZLO_LOCAL_WP_SECRET: siteSecret,
+		KIZLO_CONNECT: "local"
+	}, new Set(WP_ENV_KEYS), envGroups(DEFAULT_ENV_KEYS));
 	writeFileSync(envPath, content);
 	return {
 		siteSecret,
@@ -110,19 +107,19 @@ function updateWpEnv(cfg, info) {
 	};
 }
 /**
-* Re-point `KIZLO_DEV_WORDPRESS_URL` at the current dev URL on a warm resume, so a LAN address that
+* Re-point `KIZLO_LOCAL_WP_URL` at the current 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) {
+function syncLocalUrl(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"));
+	if (readEnvValue(existing, "KIZLO_LOCAL_WP_URL") === url) return false;
+	const { content } = mergeEnv(existing, { KIZLO_LOCAL_WP_URL: url }, new Set(["KIZLO_LOCAL_WP_URL"]), envGroups(DEFAULT_ENV_KEYS));
 	writeFileSync(envPath, content);
 	return true;
 }
@@ -134,7 +131,7 @@ function syncDevUrl(cfg, url) {
 * `next dev` child server — nothing stops them automatically when we die. A dying process
 * also can't be trusted to finish async work (a closed terminal breaks its stdout
 * mid-write), so this process does no docker work on the way out. It only needs to
-* *exit*; the watchdog, watching our PID from its own session, stops the stack the moment
+* *exit*; the watchdog, watching our PID from its own session, stops it the moment
 * we're gone — by Ctrl+C, SIGTERM, a closed tab, SIGKILL, or a crash alike.
 *
 * We trigger that exit two ways, because neither alone is enough: signal handlers (for
@@ -150,7 +147,7 @@ function armForegroundTeardown(cfg) {
 		exiting = true;
 		unregisterSession(cfg.project);
 		try {
-			note(`Stopping dev stack (${reason})…`);
+			note(`Stopping local WordPress (${reason})…`);
 		} catch {}
 		process.exit(0);
 	};
@@ -169,7 +166,7 @@ function armForegroundTeardown(cfg) {
 	}
 }
 /**
-* Boot the stack and run in the foreground until exit — the path behind bare
+* Boot local WordPress and run in the foreground until exit — the path behind bare
 * `kizlo dev`. Arms teardown first (so a mid-startup cancel still
 * stops partial containers), shows a timed spinner, prints the summary + stop hint, then
 * parks. A referenced timer holds the event loop open — an unresolved promise alone would
@@ -196,7 +193,7 @@ async function startForeground(cfg) {
 	if (dbPort !== cfg.dbPort) note(`Database port ${cfg.dbPort} is in use — using ${dbPort} instead.`);
 	armForegroundTeardown(ready);
 	const start = Date.now();
-	const creds = await withSpinner("Starting WordPress dev stack", () => bootstrapDev(ready));
+	const creds = await withSpinner("Starting local WordPress", () => bootstrapDev(ready));
 	if (creds.appPassword) {
 		const env = updateWpEnv(ready, creds);
 		note("Updated .env with the new WordPress credentials");
@@ -212,12 +209,12 @@ 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");
+	} else if (syncLocalUrl(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;
 	const took = ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
-	process.stdout.write(`\n   ${dim}Press ${reset}${bold}Ctrl+C${reset}${dim} (or close the terminal) to stop the development stack${reset}\n`);
+	process.stdout.write(`\n   ${dim}Press ${reset}${bold}Ctrl+C${reset}${dim} (or close the terminal) to stop local WordPress${reset}\n`);
 	process.stdout.write(`\n ${green}✓${reset} Ready in ${took}\n\n`);
 	const stopWatcher = await startWatcher(ready.configDir);
 	if (stopWatcher) process.on("exit", stopWatcher);
@@ -225,8 +222,8 @@ async function startForeground(cfg) {
 	await new Promise(() => {});
 }
 /**
-* Run the contract watcher in the foreground until exit — the path bare `kizlo dev` takes when no
-* local dev stack is configured (a bring-your-own-WordPress project). Generates once, then watches
+* Run the contract watcher in the foreground until exit — the path bare `kizlo dev` takes when local
+* WordPress isn't configured (a project pointing at its own WordPress). Generates once, then watches
 * the server files and regenerates on save. Returns immediately when another watcher already holds
 * the lock; otherwise the persistent watcher keeps the process alive on its own.
 */
@@ -244,44 +241,39 @@ async function watchOnly(cwd) {
 	});
 }
 /**
-* Start (or resume) the dev stack. Backs bare `kizlo dev`. Always runs in the foreground
-* and stops the stack on exit, so it never outlives the session — the subcommands
-* (`stop`/`down`/`reset`) manage everything else. Without a local dev stack configured
-* (`dev.path` unset), there's nothing to boot, so it runs the contract watcher alone.
+* Start (or resume) local WordPress. Backs bare `kizlo dev`. Always runs in the foreground and stops
+* it on exit, so it never outlives the session — the subcommands (`stop`/`reset`) manage everything
+* else. Without local WordPress configured there's nothing to boot, so it runs the contract watcher
+* alone.
 */
 async function bringUp() {
 	const cwd = process.cwd();
-	if (!await hasDevStack(cwd)) {
+	if (!await usesLocalWordPress(cwd)) {
+		note("This project doesn't run local WordPress — running the contract watcher only. Set `dev.local` in kizlo.config.ts to add it.");
 		await watchOnly(cwd);
 		return;
 	}
+	const status = await dockerStatus();
+	if (status !== "running") {
+		note(dockerHint(status));
+		process.exit(1);
+	}
 	const reaped = await reapOrphans();
-	if (reaped.length) note(`Stopped ${reaped.length} orphaned dev stack${reaped.length === 1 ? "" : "s"}: ${reaped.join(", ")}`);
+	if (reaped.length) note(`Stopped ${reaped.length} orphaned local WordPress${reaped.length === 1 ? "" : "s"}: ${reaped.join(", ")}`);
 	const cfg = await resolveDevConfig(cwd);
-	if (!cfg.wordpressPath.startsWith("..")) ensureGitignored(cfg.configDir, cfg.wordpressPath);
+	ensureGitignored(cfg.configDir, ".kizlo/");
 	await startForeground(cfg);
 }
 const subCommands = {
 	stop: defineCommand({
 		meta: {
 			name: "stop",
-			description: "Stop the dev stack, keeping the database volume"
-		},
-		async run() {
-			if (!await requireDevStack(process.cwd())) return;
-			const { stack } = await resolve$1(process.cwd());
-			await withSpinner("Stopping WordPress dev stack", () => stack.composeStop(), "Stack stopped (volumes kept)");
-		}
-	}),
-	down: defineCommand({
-		meta: {
-			name: "down",
-			description: "Stop and remove the dev stack containers (keeps the database and files)"
+			description: "Stop local WordPress, keeping the database volume"
 		},
 		async run() {
-			if (!await requireDevStack(process.cwd())) return;
+			if (!await requireLocalWordPress(process.cwd())) return;
 			const { stack } = await resolve$1(process.cwd());
-			await withSpinner("Removing WordPress dev stack", () => stack.composeDown(), "Stack removed (database and files kept)");
+			await withSpinner("Stopping local WordPress", () => stack.composeStop(), "Local WordPress stopped (volumes kept)");
 		}
 	}),
 	reset: defineCommand({
@@ -290,21 +282,21 @@ const subCommands = {
 			description: "Wipe the database and the install folder so the next `kizlo dev` rebuilds fresh"
 		},
 		async run() {
-			if (!await requireDevStack(process.cwd())) return;
+			if (!await requireLocalWordPress(process.cwd())) return;
 			const { cfg, stack } = await resolve$1(process.cwd());
-			await withSpinner("Wiping WordPress dev stack", () => stack.composeDown({ volumes: true }), "Local WordPress reset successfully");
+			await withSpinner("Wiping local WordPress", () => stack.composeDown({ volumes: true }), "Local WordPress reset successfully");
 			rmSync(cfg.wordpressDir, {
 				recursive: true,
 				force: true
 			});
-			note("Run `kizlo dev` to rebuild a fresh stack.");
+			note("Run `kizlo dev` to rebuild fresh.");
 		}
 	})
 };
 const dev = defineCommand({
 	meta: {
 		name: "dev",
-		description: "Run the dev stack and contract watcher (stop | down | reset)"
+		description: "Run local WordPress and the contract watcher (stop | reset)"
 	},
 	subCommands,
 	run: groupDefault(Object.keys(subCommands), bringUp)