kizlo 0.13.0 → 0.14.0

package/dist/cli/commands/_setup.js

@@ -1,6 +1,7 @@
 import { LOCAL_DIR_REL } from "../wp/constants.js";
 import { composeStop, createStack, dockerHint, dockerStatus } from "../wp/docker.js";
 import { DEFAULT_ENV_KEYS, availablePackageManagers, detectInvokingPackageManager, ensureGitignored, envGroups, envKeysPresent, mergeEnv, pickStackPort, writeFileIfAbsent } from "../utils.js";
+import { promptFragment, resolvePromptDefault } from "../presets/template.js";
 import { DEFAULT_DEV_DB_PORT, DEFAULT_DEV_PORT, resolveStackName, stackProject } from "../daemon/config.js";
 import { createAdminAppPassword } from "../wp/bootstrap.js";
 import { bootstrapDev } from "../wp/dev.js";
@@ -126,6 +127,54 @@ async function selectPackageManager(message) {
 		initialValue
 	}));
 }
+/** The choices summary shows a prompt under a short label — the title-cased token (`linter` → `Linter`). */
+function promptLabel(token) {
+	return token.charAt(0).toUpperCase() + token.slice(1);
+}
+/** What a resolved prompt answer reads as in the choices summary: the option label, `Yes`/`No`, or the text. */
+function promptDisplay(prompt, answer) {
+	if (prompt.kind === "confirm") return answer ? "Yes" : "No";
+	if (prompt.kind === "select") return prompt.options.find((opt) => opt.value === answer)?.label ?? String(answer);
+	return answer === "" ? "(default)" : String(answer);
+}
+/**
+* Ask the template's own prompts and turn the answers into `bootstrap` substitutions. Each prompt maps its
+* answer to a CLI fragment (via {@link promptFragment}) keyed by the prompt's `{{token}}`, which
+* `bootstrapArgs` splices into the framework command — so a template surfaces a real framework choice
+* without the CLI knowing anything framework-specific. Non-interactive (`--yes`) resolves every prompt to
+* its {@link resolvePromptDefault} with no I/O. Returns the token→fragment map plus the choices-summary rows.
+*/
+async function collectTemplatePrompts(manifest, opts) {
+	const args = {};
+	const rows = [];
+	for (const prompt of manifest.create?.prompts ?? []) {
+		let answer;
+		if (opts.yes) answer = resolvePromptDefault(prompt).answer;
+		else if (prompt.kind === "select") answer = orCancel(await p.select({
+			message: prompt.message,
+			options: prompt.options.map((opt) => ({
+				value: opt.value,
+				label: opt.label
+			})),
+			initialValue: prompt.default ?? prompt.options[0]?.value
+		}));
+		else if (prompt.kind === "confirm") answer = orCancel(await p.confirm({
+			message: prompt.message,
+			initialValue: prompt.default
+		}));
+		else answer = orCancel(await p.text({
+			message: prompt.message,
+			placeholder: prompt.placeholder,
+			defaultValue: prompt.default ?? ""
+		}));
+		args[prompt.token] = promptFragment(prompt, answer);
+		rows.push([promptLabel(prompt.token), promptDisplay(prompt, answer)]);
+	}
+	return {
+		args,
+		rows
+	};
+}
 /** Appends the API path to the base URL so the client and route handler agree. */
 function withApiPath(baseUrl, apiPath) {
 	try {
@@ -329,29 +378,21 @@ async function provisionLocalStack(cfg, siteSecret, baseUrl) {
 	};
 }
 /**
-* Provision local WordPress and fill the connection's WP credentials from it, then report the
-* outcome. Mutates `conn` in place (wpUrl / wpUsername / wpPassword). Writing the `local` flags into
-* `kizlo.config.ts` is the caller's job (the generated config for `create`/`init`). Exits on failure.
-* No-op for a remote connection.
+* Provision local WordPress and fill the connection's WP credentials from it. Mutates `conn` in place
+* (wpUrl / wpUsername / wpPassword / adminPassword). Owns no spinner and never exits — it runs as one
+* step of the execute checklist, so it throws on failure for the runner to render, and returns a
+* non-fatal warning string (or `undefined`) the caller surfaces after the run. Writing the `local` flags
+* into `kizlo.config.ts` is the caller's job. No-op for a remote connection.
 */
-async function setupLocalWordPress(cwd, conn) {
-	if (conn.mode !== "local") return;
+async function provisionLocalWordPress(cwd, conn) {
+	if (conn.mode !== "local") return void 0;
 	ensureGitignored(cwd, ".kizlo/");
-	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), conn.siteSecret, conn.baseUrl);
-		conn.wpUrl = local.url;
-		conn.wpUsername = local.username;
-		conn.wpPassword = local.appPassword;
-		conn.adminPassword = local.adminPassword;
-		s.stop("Local WordPress ready");
-		if (local.secretSyncError) p.log.warn(`Could not sync KIZLO_LOCAL_WP_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 local = await provisionLocalStack(devConfigFor(cwd), conn.siteSecret, conn.baseUrl);
+	conn.wpUrl = local.url;
+	conn.wpUsername = local.username;
+	conn.wpPassword = local.appPassword;
+	conn.adminPassword = local.adminPassword;
+	return local.secretSyncError ? `Could not sync KIZLO_LOCAL_WP_SECRET to the local plugin (${local.secretSyncError})` : void 0;
 }
 /**
 * The template's own `.env.example`, when it ships one. Templates own the framework-specific key names
@@ -374,45 +415,43 @@ function generatedEnvExample(envKeys) {
 	return `${content}\n# Point the app at local WordPress (managed by \`kizlo dev\`) instead of the keys above:\n# ${envKeys.local.connect}=local\n`;
 }
 /**
-* Write (or update) `.env` and `.env.example` for the managed keys and report the outcome.
-* Existing conflicting `.env` values are preserved unless `force`; interactively the user is asked,
-* and under `--yes` they are kept. `.env.example` is only written when absent, and is sourced from the
-* template's own file (`opts.exampleTemplate`) so it matches the `.env` structure, falling back to a
-* generated block for the base preset.
+* The managed keys already present in an existing `.env` — the values a write would overwrite. Collected
+* up front (before anything runs) so the overwrite decision is made during the lazy prompt phase and
+* passed to {@link writeEnv} as a resolved `overwrite` flag, rather than {@link writeEnv} stopping to ask
+* mid-checklist. Empty when there's no `.env` or nothing collides.
 */
-async function writeEnv(cwd, envKeys, conn, opts) {
+function envConflicts(cwd, envKeys, conn) {
+	const { keys } = managedEnv(envKeys, conn);
+	const envPath = path.join(cwd, ".env");
+	if (!fs.existsSync(envPath)) return [];
+	return envKeysPresent(fs.readFileSync(envPath, "utf8"), keys);
+}
+/**
+* Write (or update) `.env` and `.env.example` for the managed keys and return a one-line summary for the
+* checklist. Runs as a step of the execute phase, so it neither prompts nor logs: `overwrite` (whether to
+* replace conflicting values) is decided during collection — see {@link envConflicts} — and passed in.
+* `.env.example` is only written when absent, sourced from the template's own file (`opts.exampleTemplate`)
+* so it matches the `.env` structure, falling back to a generated block for the base preset.
+*/
+function writeEnv(cwd, envKeys, conn, opts) {
 	const { keys, values: envValues } = managedEnv(envKeys, conn);
 	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 && !opts.force) if (opts.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(envKeys));
+	const merge = mergeEnv(envExisted ? fs.readFileSync(envPath, "utf8") : "", envValues, opts.overwrite ? new Set(keys) : /* @__PURE__ */ new Set(), envGroups(envKeys));
 	fs.writeFileSync(envPath, merge.content);
 	const exampleBody = opts.exampleTemplate ?? generatedEnvExample(envKeys);
 	const exampleCreated = writeFileIfAbsent(path.join(cwd, ".env.example"), exampleBody);
-	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)");
+	const envMsg = !envExisted ? "Created .env" : merge.updated.length || merge.added.length ? "Updated .env" : "Left .env unchanged";
+	return exampleCreated ? `${envMsg}, created .env.example` : envMsg;
 }
 /**
-* Push the site settings (secret, canonical site URL, backend URL) to a remote WordPress so
-* webhook signing and event delivery work. No-op for local (handled during provisioning) or when
-* credentials are incomplete. Warns and continues on failure.
+* Push the site settings (secret, canonical site URL, backend URL) to a remote WordPress so webhook
+* signing and event delivery work. No-op for local (handled during provisioning) or when credentials are
+* incomplete. Runs as a checklist step, so instead of logging it returns any non-fatal warnings (a failed
+* sync, an outdated plugin) for the caller to surface after the run; success returns an empty array.
 */
 async function syncRemote(conn) {
-	if (conn.mode !== "remote" || !conn.wpUrl || !conn.wpUsername || !conn.wpPassword) return;
+	if (conn.mode !== "remote" || !conn.wpUrl || !conn.wpUsername || !conn.wpPassword) return [];
 	const sync = await syncSiteSettings({
 		url: conn.wpUrl,
 		username: conn.wpUsername,
@@ -422,11 +461,8 @@ async function syncRemote(conn) {
 		siteUrl: conn.siteUrl,
 		backendUrl: conn.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.`);
-		return;
-	}
-	if (!isPluginVersionSupported(sync.pluginVersion)) p.log.warn(pluginUpdateMessage(sync.pluginVersion));
+	if (!sync.ok) return [`Could not sync the site settings to WordPress (${sync.error}) — make sure the kizlo plugin is active, then set them from the Kizlo settings.`];
+	return isPluginVersionSupported(sync.pluginVersion) ? [] : [pluginUpdateMessage(sync.pluginVersion)];
 }
 /** The "Next steps" lines. `kizlo dev` is the single entry point for development. */
 function nextStepsLines(conn, prefix = "") {
@@ -447,4 +483,4 @@ function nextStepsNote(conn, prefix = "") {
 }
 
 //#endregion
-export { collectConnectionFromEnv, collectConnectionInteractively, dirPath, nextStepsLines, nextStepsNote, orCancel, pickAppPort, readEnvExample, resolveEnvKeys, selectPackageManager, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv };
+export { collectConnectionFromEnv, collectConnectionInteractively, collectTemplatePrompts, dirPath, envConflicts, nextStepsLines, nextStepsNote, orCancel, pickAppPort, provisionLocalWordPress, readEnvExample, resolveEnvKeys, selectPackageManager, syncRemote, validate, withApiPath, writeEnv };

package/dist/cli/commands/_tasks.js

@@ -0,0 +1,152 @@
+import { orCancel } from "./_setup.js";
+import * as p from "@clack/prompts";
+import { S_BAR, S_RADIO_INACTIVE, S_STEP_ERROR, S_STEP_SUBMIT, isCI, isTTY, unicode } from "@clack/prompts";
+import { styleText } from "node:util";
+
+//#region src/cli/commands/_tasks.ts
+const FINAL_CONFIRMATION_TEXT = "Continue with these choices?";
+/**
+* A failed checklist step. Throwing this from a step's `run` renders the step with an error mark (never a
+* checkmark) and prints its optional `detail` (captured command output, a stack) below the block. `fatal`
+* (the default) also stops the run — no later step executes. A step that failed but the setup can recover
+* from (an install or git init that didn't complete) throws with `fatal: false`: it still shows the error
+* mark, but the run carries on to the remaining steps.
+*/
+var StepError = class extends Error {
+	detail;
+	fatal;
+	constructor(message, opts = {}) {
+		super(message);
+		this.name = "StepError";
+		this.detail = opts.detail;
+		this.fatal = opts.fatal ?? true;
+	}
+};
+/** The animated in-progress frames and cadence, matching clack's own spinner. */
+const FRAMES = unicode ? [
+	"◒",
+	"◐",
+	"◓",
+	"◑"
+] : [
+	"•",
+	"o",
+	"O",
+	"0"
+];
+const FRAME_MS = unicode ? 80 : 120;
+/** A checkmark for completed steps, in place of clack's `◇`; falls back to clack's `o` where unicode isn't supported. */
+const S_DONE = unicode ? "✓" : S_STEP_SUBMIT;
+/** One checklist line: a state marker, two spaces, then the label (truncated to keep it a single row). */
+function renderLine(state, label, frame, columns) {
+	const budget = Math.max(1, columns - 3);
+	const text = label.length > budget ? `${label.slice(0, budget - 1)}…` : label;
+	switch (state) {
+		case "done": return `${styleText("green", S_DONE)}  ${text}`;
+		case "error": return `${styleText("red", S_STEP_ERROR)}  ${text}`;
+		case "active": return `${styleText("magenta", frame)}  ${text}`;
+		default: return styleText("dim", `${S_RADIO_INACTIVE}  ${text}`);
+	}
+}
+/**
+* Run the enabled steps as a single live checklist. The whole list is drawn up front — every step visible
+* at once — and repainted in place as work moves down it: a pending marker becomes an animated loader
+* while a step runs, then a checkmark with the step's completion message. A step that throws is fatal: it
+* gets an error mark, the rest stay pending, its {@link StepError} detail is printed below, and the run
+* stops. Returns whether it aborted, so the caller can exit without printing a "ready" outro over a
+* failed setup. Falls back to committing one line per step (no animation) when stdout isn't an
+* interactive TTY, so piped or CI output stays readable.
+*/
+async function runChecklist(input) {
+	const steps = input.filter((step) => step.enabled !== false).map((step) => ({
+		step,
+		state: "pending",
+		label: step.title
+	}));
+	if (steps.length === 0) return false;
+	const out = process.stdout;
+	out.write(`${styleText("gray", S_BAR)}\n`);
+	if (!isTTY(out) || isCI()) {
+		const details$1 = [];
+		let aborted$1 = false;
+		for (const item of steps) try {
+			const done = await item.step.run(() => {});
+			out.write(`${styleText("green", S_DONE)}  ${done.length > 0 ? done : item.step.title}\n`);
+		} catch (error) {
+			out.write(`${styleText("red", S_STEP_ERROR)}  ${error instanceof Error ? error.message : String(error)}\n`);
+			if (error instanceof StepError && error.detail) details$1.push(error.detail);
+			if (!(error instanceof StepError) || error.fatal) {
+				aborted$1 = true;
+				break;
+			}
+		}
+		for (const detail of details$1) p.log.error(detail);
+		return aborted$1;
+	}
+	const columns = out.columns || 80;
+	let frame = 0;
+	const draw = (first) => {
+		if (!first) {
+			out.moveCursor(0, -steps.length);
+			out.cursorTo(0);
+			out.clearScreenDown();
+		}
+		out.write(`${steps.map((item) => renderLine(item.state, item.label, FRAMES[frame % FRAMES.length] ?? "", columns)).join("\n")}\n`);
+	};
+	out.write("\x1B[?25l");
+	draw(true);
+	const timer = setInterval(() => {
+		frame++;
+		draw(false);
+	}, FRAME_MS);
+	const details = [];
+	let aborted = false;
+	try {
+		for (const item of steps) {
+			item.state = "active";
+			draw(false);
+			try {
+				const done = await item.step.run((text) => {
+					item.label = text;
+				});
+				item.label = done.length > 0 ? done : item.step.title;
+				item.state = "done";
+				draw(false);
+			} catch (error) {
+				item.label = error instanceof Error ? error.message : String(error);
+				item.state = "error";
+				draw(false);
+				if (error instanceof StepError && error.detail) details.push(error.detail);
+				if (!(error instanceof StepError) || error.fatal) {
+					aborted = true;
+					break;
+				}
+			}
+		}
+	} finally {
+		clearInterval(timer);
+		out.write("\x1B[?25h");
+	}
+	for (const detail of details) p.log.error(detail);
+	return aborted;
+}
+/**
+* The "here's everything you chose" note shown after collecting inputs and before running any step —
+* the heart of the lazy flow: nothing has happened yet, and the user reviews the whole plan at once.
+* Labels are padded to a common width so the values line up in a column.
+*/
+function summaryNote(rows, title = "Review your choices") {
+	const width = Math.max(...rows.map(([label]) => label.length));
+	const body = rows.map(([label, value]) => `${`${label}:`.padEnd(width + 1)}   ${value}`).join("\n");
+	p.note(body, title);
+}
+/** Ask the single go/no-go question that gates the execute phase. Cancelling exits cleanly. */
+async function confirmProceed(message) {
+	return orCancel(await p.confirm({
+		message,
+		initialValue: true
+	}));
+}
+
+//#endregion
+export { FINAL_CONFIRMATION_TEXT, StepError, confirmProceed, runChecklist, summaryNote };

package/dist/cli/commands/_wiring.js

@@ -22,21 +22,22 @@ export default defineConfig({
 `;
 }
 /**
-* Build the {@link ScaffoldContext} that adapts a template's conventions (paths and imports) to a real
-* project. `dirRel` is the Kizlo home directory, `appDir` the App Router directory, and `alias` the
-* import-alias prefix (empty for relative imports). Imports are resolved per calling file so each
-* scaffolded file references its targets through the right specifier — `importFrom` for any project
-* path (used to retarget every template-alias import), `serverImport` the server-entry shorthand.
+* Build the {@link ScaffoldContext} that adapts a template's config (paths and imports) to a real
+* project. `dirRel` is the Kizlo home directory, `hasSrcDir` whether the project keeps source under
+* `src/` (decides the `src/` normalization of template paths), and `alias` the import-alias prefix (empty
+* for relative imports). Imports are resolved per calling file so each scaffolded file references its
+* targets through the right specifier — `importFrom` for any project path (used to retarget every
+* template-alias import), `serverImport` the server-entry shorthand.
 */
-function buildScaffoldContext(cwd, { dirRel, appDir, alias, clientUrl }) {
+function buildScaffoldContext(cwd, { dirRel, hasSrcDir, alias, clientUrl }) {
 	const serverDirRel = path.join(dirRel, "server");
 	const importFrom = (targetRel, fromDir) => resolveModuleImport(cwd, targetRel, fromDir, alias);
 	return {
-		kizloDir: dirRel,
+		kizloPath: dirRel,
 		serverDirName: path.basename(serverDirRel),
 		serverEntryPath: path.join(serverDirRel, "index.ts"),
 		clientPath: path.join(dirRel, "client.ts"),
-		appDir,
+		hasSrcDir,
 		serverImport: (fromDir) => importFrom(serverDirRel, fromDir),
 		importFrom,
 		clientUrl
@@ -86,10 +87,10 @@ function writeGeneratedContract(cwd, serverDirRel) {
 * written to a guessed-at file. We never scan the tree to find a stand-in. A confident apply is an
 * idempotent upsert: it replaces our exports if present, adds them if not.
 */
-function applyProjectPatches(cwd, patches, conventions, scaffold) {
+function applyProjectPatches(cwd, patches, config, scaffold) {
 	const manualSteps = [];
 	for (const entry of patches) {
-		const resolved = resolvePatch(entry, conventions, scaffold);
+		const resolved = resolvePatch(entry, config, scaffold);
 		if (resolved.mode === "note") {
 			manualSteps.push(resolved);
 			p.log.info(`Update your ${resolved.label} to finish wiring Kizlo — see the change to make below`);