kizlo 0.13.0 → 0.14.0

package/dist/cli/commands/create.js

@@ -1,8 +1,9 @@
-import { approveBuildsCommand, ensureGitignored, frameworkCreateArgs, initGitRepository, installArgs, isCommandAvailable, isGitRepository, runCommandCaptured, runCommandCapturedAsync } from "../utils.js";
+import { approveBuildsCommand, cleanupWorkspaceArtifacts, detectInvokingPackageManager, detectPackageManager, ensureGitignored, findWorkspaceRoot, initGitRepository, installArgs, isCommandAvailable, isGitRepository, isWorkspaceMember, runCommandCapturedAsync, tokenizeCommand } from "../utils.js";
 import { fetchRegistry, listTemplates, resolveRegistry } from "../presets/source.js";
 import { adaptFile, changesFor, fileEntries, minCliError, patchEntries, readManifest, resolveDependencies } from "../presets/template.js";
-import { collectConnectionInteractively, nextStepsLines, orCancel, pickAppPort, readEnvExample, resolveEnvKeys, selectPackageManager, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
-import { applyProjectPatches, buildScaffoldContext, kizloConfigTemplate, reportScaffold, scaffoldFile, writeGeneratedContract } from "./_wiring.js";
+import { collectConnectionFromEnv, collectConnectionInteractively, collectTemplatePrompts, nextStepsLines, orCancel, pickAppPort, provisionLocalWordPress, readEnvExample, resolveEnvKeys, selectPackageManager, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
+import { FINAL_CONFIRMATION_TEXT, StepError, confirmProceed, runChecklist, summaryNote } from "./_tasks.js";
+import { applyProjectPatches, buildScaffoldContext, kizloConfigTemplate, scaffoldFile, writeGeneratedContract } from "./_wiring.js";
 import z from "zod/v4";
 import path from "node:path";
 import fs from "node:fs";
@@ -24,12 +25,94 @@ function normalizeProjectName(value) {
 	return value.trim().replace(/^\.\/+/, "").replace(/[/\\]+$/, "");
 }
 /**
-* A project name may be a bare folder (`my-app`) or a path to scaffold somewhere other than the current
-* dir — relative (`apps/my-app`, `../my-app`) or absolute (`/srv/my-app`). Only the last segment is the
-* app folder, so that's what's validated as a name; the parent dirs (which may not exist yet) are created
-* by the framework's own CLI. `.`/`..` as the final segment, or a name with no real segment, is rejected.
+* How a chosen name is shown back to the user. A bare folder is displayed as `./my-app` so it's obvious it
+* lands in the current dir; a name that's already a path (relative `apps/my-app`, `../my-app`, or an
+* absolute path) is shown as-is. Display only — the stored name stays normalized (no leading `./`).
+*/
+function displayProjectName(value) {
+	return /[/\\]/.test(value) ? value : `./${value}`;
+}
+const NAME_ADJECTIVES = [
+	"amber",
+	"brave",
+	"calm",
+	"clever",
+	"cosmic",
+	"eager",
+	"fancy",
+	"gentle",
+	"happy",
+	"jolly",
+	"keen",
+	"lively",
+	"lucky",
+	"mellow",
+	"nimble",
+	"plucky",
+	"quiet",
+	"rapid",
+	"shiny",
+	"smooth",
+	"sunny",
+	"swift",
+	"witty",
+	"zesty"
+];
+const NAME_NOUNS = [
+	"otter",
+	"falcon",
+	"maple",
+	"comet",
+	"harbor",
+	"pixel",
+	"willow",
+	"ember",
+	"meadow",
+	"cactus",
+	"lotus",
+	"badger",
+	"cobra",
+	"gecko",
+	"heron",
+	"koala",
+	"lemur",
+	"marble",
+	"nebula",
+	"onyx",
+	"quartz",
+	"raven",
+	"tulip",
+	"wren"
+];
+/**
+* A throwaway two-word name (`brave-otter`) used as the name prompt's placeholder and default. We
+* generate it from small curated word lists rather than pulling in a name-generator dependency: it's
+* only a placeholder, and every combination is a valid folder name that satisfies `projectNameSchema`.
+* The default is deliberately not the current directory's name — an empty submit should scaffold into a
+* fresh subdirectory, never the current dir (entering `.` is the explicit opt-in for that).
+*/
+function randomProjectName() {
+	const pick = (list) => list[Math.floor(Math.random() * list.length)];
+	return `${pick(NAME_ADJECTIVES)}-${pick(NAME_NOUNS)}`;
+}
+const SCAFFOLD_IGNORED_ENTRIES = new Set([".git", ".DS_Store"]);
+/**
+* Whether `dir` is empty enough to scaffold into with `.` — nothing but the benign entries above. Used to
+* reject scaffolding over a non-empty current directory before the framework CLI runs (it would refuse
+* anyway, but this gives a clear Kizlo-level message instead of the CLI's).
+*/
+function isDirScaffoldable(dir) {
+	return fs.readdirSync(dir).every((entry) => SCAFFOLD_IGNORED_ENTRIES.has(entry));
+}
+/**
+* A project name may be a bare folder (`my-app`), a path to scaffold somewhere other than the current
+* dir — relative (`apps/my-app`, `../my-app`) or absolute (`/srv/my-app`) — or a lone `.` to scaffold
+* into the current directory itself. Only the last segment is the app folder, so that's what's validated
+* as a name; the parent dirs (which may not exist yet) are created by the framework's own CLI. `.`/`..`
+* as the final segment of a longer path, or a name with no real segment, is rejected.
 */
 const projectNameSchema = z.string().trim().min(1, "Required").refine((value) => {
+	if (value === ".") return true;
 	const base = folderSegment(value);
 	return base.length > 0 && base !== "." && base !== ".." && /^[A-Za-z0-9._-]+$/.test(base);
 }, "The app folder (last path segment) can only contain letters, numbers, dots, and dashes");
@@ -63,16 +146,29 @@ function sortDependencies(deps) {
 	return Object.fromEntries(Object.entries(deps).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
 }
 /**
-* The argv `create` runs to bootstrap a fresh base app with the framework's own official CLI, built
-* from the template manifest's `bootstrap` (initializer + flags) — the template is the single source
-* of truth for the framework. The CLI owns only the package-manager mechanics: {@link frameworkCreateArgs}
-* assembles the `<pm> create …` invocation, and the `{{pm}}` token in the flags is substituted with the
-* chosen manager (e.g. `--use-{{pm}}` → `--use-pnpm`).
+* Each manager's command to download-and-run a package (npm's `create` mangles a name into `create-*`, so
+* a plain CLI like `@tanstack/cli` must go through exec instead). Substituted for the `{{dlx}}` token.
+*/
+const DLX_COMMAND = {
+	pnpm: "pnpm dlx",
+	yarn: "yarn dlx",
+	npm: "npx",
+	bun: "bunx"
+};
+/**
+* The argv `create` runs to bootstrap a fresh base app with the framework's own official CLI, built from
+* the template manifest's `bootstrap` command — the template is the single source of truth for the whole
+* invocation. The CLI imposes no shape: it substitutes the `{{dlx}}` (the manager's exec command),
+* `{{pm}}` (chosen manager), and `{{name}}` (project name) tokens, plus a `{{token}}` for every declared
+* prompt (from `promptArgs`), then tokenizes the result into argv. A prompt fragment may be empty (drops
+* out when tokenized) or several flags. `undefined` when the manifest declares no bootstrap (an
+* `init`-only template).
 */
-function bootstrapArgs(manifest, pm, name) {
-	if (!manifest.bootstrap) return void 0;
-	const flags = manifest.bootstrap.flags.map((flag) => flag.replaceAll("{{pm}}", pm));
-	return frameworkCreateArgs(pm, manifest.bootstrap.initializer, name, flags);
+function bootstrapArgs(manifest, pm, name, promptArgs = {}) {
+	if (!manifest.create) return void 0;
+	let command = manifest.create.command.replaceAll("{{dlx}}", DLX_COMMAND[pm]).replaceAll("{{pm}}", pm).replaceAll("{{name}}", name);
+	for (const [token, fragment] of Object.entries(promptArgs)) command = command.replaceAll(`{{${token}}}`, fragment);
+	return tokenizeCommand(command);
 }
 /**
 * Layer Kizlo's wiring onto a freshly bootstrapped app in `dir`, from an already-fetched template
@@ -87,10 +183,10 @@ function bootstrapArgs(manifest, pm, name) {
 * files are written with `force`, silently replacing the framework defaults.
 */
 async function applyManifestWiring(dir, templateDir, manifest, opts) {
-	const { kizloDir, appDir, alias } = manifest.conventions;
+	const { alias, kizloPath } = manifest.config;
 	const scaffold = buildScaffoldContext(dir, {
-		dirRel: kizloDir,
-		appDir,
+		dirRel: kizloPath,
+		hasSrcDir: fs.existsSync(path.join(dir, "src")),
 		alias,
 		clientUrl: void 0
 	});
@@ -99,16 +195,16 @@ async function applyManifestWiring(dir, templateDir, manifest, opts) {
 	const files = [{
 		label: "Kizlo config",
 		relPath: "kizlo.config.ts",
-		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, {
+		contents: kizloConfigTemplate(kizloPath, alias, opts.localDev)
+	}, ...fileEntries(changes).map((entry) => adaptFile(templateDir, entry, manifest.config, scaffold))];
+	for (const file of files) await scaffoldFile(dir, file, {
 		force: true,
 		yes: false
-	}), false);
-	writeGeneratedContract(dir, path.join(kizloDir, "server"));
+	});
+	writeGeneratedContract(dir, path.join(kizloPath, "server"));
 	ensureGitignored(dir, ".env");
 	ensureGitignored(dir, ".kizlo/");
-	applyProjectPatches(dir, patchEntries(changes), manifest.conventions, scaffold);
+	applyProjectPatches(dir, patchEntries(changes), manifest.config, scaffold);
 }
 const create = defineCommand({
 	meta: {
@@ -126,12 +222,19 @@ const create = defineCommand({
 			required: false,
 			description: "Project folder to create — a bare name or a path (e.g. apps/my-app, ../my-app, /srv/my-app)"
 		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Skip prompts and scaffold with defaults (non-interactive); requires the template and name",
+			default: false
+		},
 		source: {
 			type: "string",
 			description: "Where to scaffold from — a local dir or giget source, either a registry of templates or a single template (default: Kizlo's GitHub templates)"
 		}
 	},
 	async run({ args }) {
+		const yes = Boolean(args.yes);
 		const cwd = process.cwd();
 		p.intro(`Let's create a new Kizlo application`);
 		const registry = resolveRegistry(args.source ? String(args.source) : void 0);
@@ -153,12 +256,14 @@ const create = defineCommand({
 			p.cancel(message);
 			process.exit(1);
 		};
+		const fail = cancelFrom;
 		const requested = args.template;
 		let selected;
 		if (requested) {
 			selected = templates.find((entry) => entry.id === requested);
 			if (!selected) return cancelFrom(`Unknown template "${requested}". Available: ${templates.map((entry) => entry.id).join(", ")}`);
-		} else {
+		} else if (yes) return cancelFrom(`--yes needs a template: kizlo create <template> <name> --yes (available: ${templates.map((e) => e.id).join(", ")})`);
+		else {
 			const id = orCancel(await p.select({
 				message: "Template",
 				options: templates.map((entry) => ({
@@ -172,83 +277,161 @@ const create = defineCommand({
 		const template = selected.id;
 		const templateDir = selected.dir;
 		const label = selected.label;
-		const fail = cancelFrom;
 		const manifest = readManifest(templateDir);
 		const minErr = minCliError(manifest);
 		if (minErr) return fail(minErr);
+		if (yes && !args.name) return cancelFrom("--yes needs a project name: kizlo create <template> <name> --yes");
+		const defaultName = randomProjectName();
 		const name = normalizeProjectName(args.name ? String(args.name) : orCancel(await p.text({
-			message: "What is your project named?",
-			placeholder: "my-app",
-			validate: projectName
+			message: `What is your project named? (enter for "${displayProjectName(defaultName)}", or "." for the current directory)`,
+			placeholder: displayProjectName(defaultName),
+			defaultValue: displayProjectName(defaultName),
+			validate: (value) => value ? projectName(value) : void 0
 		})));
 		const invalid = projectName(name);
-		if (invalid) {
-			p.cancel(invalid);
-			process.exit(1);
+		if (invalid) return cancelFrom(invalid);
+		const inCurrentDir = name === ".";
+		const displayName = inCurrentDir ? "current directory" : displayProjectName(name);
+		const dir = inCurrentDir ? cwd : path.resolve(cwd, name);
+		if (!inCurrentDir && fs.existsSync(dir)) return cancelFrom(`${name} already exists — pick a different name or remove it.`);
+		if (inCurrentDir && !isDirScaffoldable(cwd)) {
+			if (yes) return cancelFrom("The current directory isn't empty — scaffold into an empty directory, or pass a name instead of `.`.");
+			p.log.warn("The current directory isn't empty — scaffolding here may overwrite or conflict with existing files.");
+			if (!orCancel(await p.confirm({
+				message: "Scaffold into it anyway?",
+				initialValue: false
+			}))) {
+				fetchedRegistry.cleanup();
+				p.cancel("Setup cancelled.");
+				process.exit(0);
+			}
 		}
-		const dir = path.resolve(cwd, name);
-		if (fs.existsSync(dir)) return cancelFrom(`${name} already exists — pick a different name or remove it.`);
-		const pm = await selectPackageManager("Package manager");
-		const conn = await collectConnectionInteractively(manifest.apiPath, { baseUrl: `http://localhost:${await pickAppPort()}` });
-		if (manifest.apiPath && conn.baseUrl) conn.baseUrl = withApiPath(conn.baseUrl, manifest.apiPath);
-		const includeExamples = orCancel(await p.confirm({
+		const parentDir = path.dirname(dir);
+		const workspace = findWorkspaceRoot(parentDir);
+		const detectedPm = await detectPackageManager(workspace?.root ?? parentDir);
+		const pm = detectedPm ?? (yes ? detectInvokingPackageManager() ?? "npm" : await selectPackageManager("Package manager"));
+		const templatePrompts = await collectTemplatePrompts(manifest, { yes });
+		const baseUrl = `http://localhost:${await pickAppPort()}`;
+		const conn = yes ? collectConnectionFromEnv(resolveEnvKeys(manifest)) : await collectConnectionInteractively(manifest.config.apiPath, { baseUrl });
+		if (yes && !conn.baseUrl) conn.baseUrl = baseUrl;
+		if (manifest.config.apiPath && conn.baseUrl) conn.baseUrl = withApiPath(conn.baseUrl, manifest.config.apiPath);
+		const includeExamples = yes ? true : orCancel(await p.confirm({
 			message: "Add examples?",
 			initialValue: true
 		}));
-		const bootstrap = bootstrapArgs(manifest, pm, name);
-		if (!bootstrap) return fail(`Template "${template}" can't be scaffolded — its manifest declares no framework bootstrap.`);
-		const s = p.spinner();
-		s.start(`Creating ${name} with the ${label} CLI`);
-		const scaffold = runCommandCaptured(bootstrap, cwd);
-		s.stop(scaffold.ok ? `Created ${name} with the ${label} CLI` : `${label} setup failed`);
-		if (!scaffold.ok) {
-			if (scaffold.output) p.log.error(scaffold.output);
-			fail(`${label} setup failed — see the output above and try again.`);
-		}
-		const exampleTemplate = readEnvExample(templateDir);
-		try {
-			await applyManifestWiring(dir, templateDir, manifest, {
-				includeExamples,
-				localDev: conn.mode === "local"
-			});
-		} catch (error) {
-			fail(error instanceof Error ? error.message : String(error));
-		}
-		fetchedRegistry.cleanup();
-		let depsInstalled = false;
-		let approveBuilds;
-		if (orCancel(await p.confirm({
+		const installDeps = yes ? true : orCancel(await p.confirm({
 			message: "Install dependencies now?",
 			initialValue: true
-		}))) {
-			const is = p.spinner();
-			is.start(`Installing dependencies with ${pm}`);
-			const install = await runCommandCapturedAsync(installArgs(pm), dir);
-			depsInstalled = install.ok;
-			if (depsInstalled) approveBuilds = approveBuildsCommand(pm, install.output);
-			is.stop(depsInstalled ? "Installed dependencies" : "Could not install dependencies");
-			if (!depsInstalled) p.log.warn(`Install them yourself: cd ${name} && ${installArgs(pm).join(" ")}`);
-		}
-		await setupLocalWordPress(dir, conn);
-		await writeEnv(dir, resolveEnvKeys(manifest), conn, {
-			force: true,
-			yes: false,
-			exampleTemplate
-		});
-		await syncRemote(conn);
-		if (isCommandAvailable("git") && !isGitRepository(dir) && orCancel(await p.confirm({
+		}));
+		const canGit = isCommandAvailable("git") && !workspace && !isGitRepository(cwd);
+		const initGit = canGit && (yes || orCancel(await p.confirm({
 			message: "Initialize a git repository?",
 			initialValue: true
-		}))) {
-			const gs = p.spinner();
-			gs.start("Initializing git repository");
-			const ok = initGitRepository(dir);
-			gs.stop(ok ? "Initialized git repository" : "Could not initialize git repository");
+		})));
+		const bootstrap = bootstrapArgs(manifest, pm, name, templatePrompts.args);
+		if (!bootstrap) return fail(`Template "${template}" can't be scaffolded — its manifest declares no framework bootstrap.`);
+		summaryNote([
+			["Template", label],
+			...templatePrompts.rows,
+			[inCurrentDir || /[/\\]/.test(name) ? "Location" : "Project", displayName],
+			["Package manager", `${pm}${detectedPm ? " (detected)" : ""}`],
+			["API URL", conn.baseUrl],
+			["WordPress", conn.mode === "local" ? "Local" : "Remote"],
+			["Examples", includeExamples ? "Yes" : "No"],
+			["Install dependencies", installDeps ? "Yes" : "No"],
+			...canGit ? [["Git repository", initGit ? "Yes" : "No"]] : []
+		]);
+		if (!yes && !await confirmProceed(FINAL_CONFIRMATION_TEXT)) {
+			fetchedRegistry.cleanup();
+			p.cancel("Setup cancelled.");
+			process.exit(0);
+		}
+		const exampleTemplate = readEnvExample(templateDir);
+		const warnings = [];
+		const result = { depsInstalled: false };
+		const aborted = await runChecklist([
+			{
+				title: inCurrentDir ? `Scaffolding into the current directory with the ${label} CLI` : `Creating ${name} with the ${label} CLI`,
+				run: async () => {
+					const scaffold = await runCommandCapturedAsync(bootstrap, cwd);
+					if (!scaffold.ok) throw new StepError(`${label} setup failed`, { detail: scaffold.output || void 0 });
+					return inCurrentDir ? `Scaffolded into the current directory with the ${label} CLI` : `Created ${name} with the ${label} CLI`;
+				}
+			},
+			{
+				title: "Wiring Kizlo into the project",
+				run: async () => {
+					await applyManifestWiring(dir, templateDir, manifest, {
+						includeExamples,
+						localDev: conn.mode === "local"
+					});
+					return "Wired Kizlo into the project";
+				}
+			},
+			{
+				title: "Setting up local WordPress (first run downloads images, this can take a while)",
+				enabled: conn.mode === "local",
+				run: async () => {
+					try {
+						const warning = await provisionLocalWordPress(dir, conn);
+						if (warning) warnings.push(warning);
+						return "Local WordPress ready";
+					} catch (error) {
+						throw new StepError("Local WordPress setup failed", { detail: error instanceof Error ? error.message : String(error) });
+					}
+				}
+			},
+			{
+				title: "Writing environment files",
+				run: () => writeEnv(dir, resolveEnvKeys(manifest), conn, {
+					overwrite: true,
+					exampleTemplate
+				})
+			},
+			{
+				title: "Syncing settings to WordPress",
+				enabled: conn.mode === "remote" && Boolean(conn.wpUrl && conn.wpUsername && conn.wpPassword),
+				run: async () => {
+					warnings.push(...await syncRemote(conn));
+					return "Synced settings to WordPress";
+				}
+			},
+			{
+				title: "Initializing git repository",
+				enabled: initGit,
+				run: () => {
+					if (!initGitRepository(dir)) throw new StepError("Could not initialize a git repository", { fatal: false });
+					return "Initialized git repository";
+				}
+			},
+			{
+				title: `Installing dependencies with ${pm}`,
+				enabled: installDeps,
+				run: async () => {
+					const member = workspace ? isWorkspaceMember(workspace, dir) : false;
+					if (member && workspace) cleanupWorkspaceArtifacts(dir);
+					const installCwd = member && workspace ? workspace.root : dir;
+					const install = await runCommandCapturedAsync(installArgs(pm), installCwd);
+					result.depsInstalled = install.ok;
+					if (!install.ok) throw new StepError("Could not install dependencies", {
+						detail: install.output || void 0,
+						fatal: false
+					});
+					result.approveBuilds = approveBuildsCommand(pm, install.output);
+					return "Installed dependencies";
+				}
+			}
+		]);
+		fetchedRegistry.cleanup();
+		if (aborted) {
+			p.cancel("Setup failed — see the errors above.");
+			process.exit(1);
 		}
+		for (const warning of warnings) p.log.warn(warning);
 		p.note([
-			`cd ${name}`,
-			...depsInstalled ? [] : [`${pm} install`],
-			...approveBuilds ? [approveBuilds] : [],
+			...inCurrentDir ? [] : [`cd ${name}`],
+			...result.depsInstalled ? [] : [`${pm} install`],
+			...result.approveBuilds ? [result.approveBuilds] : [],
 			``,
 			...nextStepsLines(conn)
 		].join("\n"), "Next steps");