kizlo 0.13.0 → 0.14.0

package/dist/cli/commands/init.js

@@ -1,7 +1,8 @@
 import { addDependencyArgs, aliasWithSlash, detectImportAlias, detectInvokingPackageManager, detectPackageManager, ensureGitignored, getVersion, loadEnvFiles, persistPackageManagerField, readPersistedAlias, runCommandAsync } from "../utils.js";
 import { DEFAULT_REGISTRY, detectTemplates, fetchRegistry, isSingleTemplate, listTemplates, resolveRegistry } from "../presets/source.js";
-import { adaptFile, changesFor, fileEntries, isOlderVersion, minCliError, patchEntries, readManifest, renderNote, resolveDependencies } from "../presets/template.js";
-import { collectConnectionFromEnv, collectConnectionInteractively, dirPath, nextStepsNote, orCancel, readEnvExample, resolveEnvKeys, selectPackageManager, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
+import { adaptFile, changesFor, fileEntries, isOlderVersion, minCliError, patchEntries, readManifest, renderNote, resolveDependencies, unmetRequirement } from "../presets/template.js";
+import { collectConnectionFromEnv, collectConnectionInteractively, dirPath, envConflicts, nextStepsNote, orCancel, 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, printManualStep, reportScaffold, scaffoldFile, writeGeneratedContract } from "./_wiring.js";
 import path from "node:path";
 import fs from "node:fs";
@@ -21,24 +22,6 @@ function sameOrigin(a, b) {
 	}
 }
 /**
-* The framework's route directory in the user's project. When a template is present its
-* `conventions.appDir` (e.g. `src/app` for Next, `src/pages` for Astro) is the expected layout; we
-* probe that path and its no-`src` variant so a project that keeps routes at the top level is still
-* found, falling back to whether the project has a `src` dir. With no known template appDir we keep the
-* App Router default.
-*/
-function detectAppDir(cwd, hasSrcDir, templateAppDir) {
-	if (templateAppDir) {
-		const withoutSrc = templateAppDir.replace(/^src\//, "");
-		if (fs.existsSync(path.join(cwd, templateAppDir))) return templateAppDir;
-		if (fs.existsSync(path.join(cwd, withoutSrc))) return withoutSrc;
-		return hasSrcDir ? templateAppDir : withoutSrc;
-	}
-	if (fs.existsSync(path.join(cwd, "src", "app"))) return "src/app";
-	if (fs.existsSync(path.join(cwd, "app"))) return "app";
-	return hasSrcDir ? "src/app" : "app";
-}
-/**
 * The import alias settled without asking — the explicit `--alias` flag, else the alias a previous init
 * persisted in kizlo.config. `undefined` when neither is set: the choice hasn't been made, so it must be
 * prompted for (interactive) or defaulted to relative imports (`--yes`). Detection never enters here — a
@@ -105,7 +88,7 @@ function readPkg(pkgPath) {
 * A *missing* `kizlo` is installed on its own earlier (with its own messaging), so it's skipped here;
 * an existing older `kizlo` still gets the upgrade path.
 */
-async function alignDependencies(cwd, pm, pkg, manifest) {
+async function alignDependencies(cwd, pm, pkg, manifest, message, warnings) {
 	const { dependencies, devDependencies } = resolveDependencies(manifest);
 	const declared = [...Object.entries(dependencies).map(([name, want]) => ({
 		name,
@@ -116,17 +99,23 @@ async function alignDependencies(cwd, pm, pkg, manifest) {
 		want,
 		dev: true
 	}))];
+	let installed = 0;
+	let upgraded = 0;
 	for (const { name, want, dev } of declared) {
 		const have = pkg.dependencies?.[name] ?? pkg.devDependencies?.[name];
 		if (name === "kizlo" && !have) continue;
 		if (have && !isOlderVersion(have, want)) continue;
 		const args = addDependencyArgs(pm, `${name}@${want}`, { dev });
-		const s = p.spinner();
-		s.start(have ? `Upgrading ${name} from ${have} to ${want}` : `Installing ${name}@${want}`);
-		const ok = await runCommandAsync(args, cwd, "ignore");
-		if (have) s.stop(ok ? `Upgraded ${name} to ${want}` : `Could not upgrade ${name} automatically — install ${name}@${want} yourself`);
-		else s.stop(ok ? `Installed ${name}@${want}` : `Could not install ${name} automatically — run \`${args.join(" ")}\` yourself`);
+		message(have ? `Upgrading ${name} from ${have} to ${want}` : `Installing ${name}@${want}`);
+		if (!await runCommandAsync(args, cwd, "ignore")) {
+			warnings.push(have ? `Could not upgrade ${name} automatically — install ${name}@${want} yourself` : `Could not install ${name} — run \`${args.join(" ")}\` yourself`);
+			continue;
+		}
+		if (have) upgraded++;
+		else installed++;
 	}
+	const parts = [installed ? `installed ${installed}` : "", upgraded ? `upgraded ${upgraded}` : ""].filter(Boolean);
+	return parts.length ? `Aligned dependencies (${parts.join(", ")})` : "Dependencies already aligned";
 }
 const init = defineCommand({
 	meta: {
@@ -174,9 +163,9 @@ const init = defineCommand({
 			process.exit(1);
 		}
 		const pkg = readPkg(pkgPath);
-		const detectedPm = detectPackageManager(cwd);
+		const detectedPm = await detectPackageManager(cwd);
 		const pm = detectedPm ?? (yes ? detectInvokingPackageManager() ?? "npm" : await selectPackageManager("Couldn't detect this project's package manager — which should Kizlo use?"));
-		if (!detectedPm && !yes) persistPackageManagerField(cwd, pm);
+		const shouldPersistPm = !detectedPm && !yes;
 		const hasKizlo = Boolean(pkg.dependencies?.kizlo) || Boolean(pkg.devDependencies?.kizlo);
 		const hasSrcDir = fs.existsSync(path.join(cwd, "src"));
 		if (yes) loadEnvFiles(cwd);
@@ -249,8 +238,9 @@ const init = defineCommand({
 			const manifest = readManifest(entry.dir);
 			const minErr = minCliError(manifest);
 			if (minErr) cancelFrom(minErr);
-			if (manifest.requires && !manifest.requires.anyDir.some((rel) => fs.existsSync(path.join(cwd, rel)))) cancelFrom(manifest.requires.message);
-			const apiPath = manifest.apiPath;
+			const unmet = unmetRequirement(manifest.init.requires, projectDeps, (rel) => fs.existsSync(path.join(cwd, rel)));
+			if (unmet) cancelFrom(unmet);
+			const apiPath = manifest.config.apiPath;
 			const envKeys = resolveEnvKeys(manifest);
 			const flagAlias = args.alias !== void 0 ? String(args.alias).trim() : void 0;
 			const aliasCtx = {
@@ -265,32 +255,17 @@ const init = defineCommand({
 				envKeys
 			}) : await collectInteractively(aliasCtx);
 			setup.alias = aliasWithSlash(setup.alias);
+			if (apiPath && setup.baseUrl) setup.baseUrl = withApiPath(setup.baseUrl, apiPath);
 			const includeExamples = yes ? true : orCancel(await p.confirm({
 				message: "Add example pages?",
 				initialValue: true
 			}));
-			if (!hasKizlo) {
-				const spec = `kizlo@${manifest.dependencies?.kizlo ?? `^${getVersion()}`}`;
-				const s = p.spinner();
-				s.start(`Installing kizlo with ${pm}`);
-				const ok = await runCommandAsync(addDependencyArgs(pm, spec), cwd, "ignore");
-				s.stop(ok ? "Installed kizlo" : "Could not install kizlo automatically");
-				if (!ok) p.log.warn(`Install it yourself: ${addDependencyArgs(pm, spec).join(" ")}`);
-			}
-			if (apiPath && setup.baseUrl) setup.baseUrl = withApiPath(setup.baseUrl, apiPath);
-			await setupLocalWordPress(cwd, setup);
-			await writeEnv(cwd, envKeys, setup, {
-				force,
-				yes,
-				exampleTemplate: readEnvExample(entry.dir)
-			});
-			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 = buildScaffoldContext(cwd, {
 				dirRel,
-				appDir: detectAppDir(cwd, hasSrcDir, manifest.conventions.appDir),
+				hasSrcDir,
 				alias: setup.alias,
 				clientUrl
 			});
@@ -299,22 +274,108 @@ const init = defineCommand({
 				relPath: "kizlo.config.ts",
 				contents: kizloConfigTemplate(dirRel, setup.alias, setup.mode === "local")
 			}];
-			await alignDependencies(cwd, pm, pkg, manifest);
-			for (const fileEntry of fileEntries(changesFor(manifest, "init", { includeExamples }))) files.push(adaptFile(entry.dir, fileEntry, manifest.conventions, scaffold));
+			for (const fileEntry of fileEntries(changesFor(manifest, "init", { includeExamples }))) files.push(adaptFile(entry.dir, fileEntry, manifest.config, scaffold));
+			const existingFiles = files.filter((file) => fs.existsSync(path.join(cwd, file.relPath)));
+			const overwritePaths = force || existingFiles.length === 0 || yes ? new Set(force ? existingFiles.map((f) => f.relPath) : []) : new Set(orCancel(await p.multiselect({
+				message: `${existingFiles.length} file(s) already exist. Select which to overwrite (space to toggle, enter to confirm).`,
+				options: existingFiles.map((f) => ({
+					value: f.relPath,
+					label: f.relPath
+				})),
+				initialValues: existingFiles.map((f) => f.relPath),
+				required: false
+			})));
+			const envKeyConflicts = envConflicts(cwd, envKeys, setup);
+			const overwriteEnv = force || envKeyConflicts.length > 0 && !yes && orCancel(await p.confirm({
+				message: `Overwrite existing .env values (${envKeyConflicts.join(", ")})?`,
+				initialValue: true
+			}));
+			summaryNote([
+				["Template", entry.label],
+				["Package manager", pm],
+				["Kizlo directory", setup.dir],
+				["Import alias", setup.alias || "relative imports"],
+				["API URL", setup.baseUrl || "fill in .env later"],
+				["WordPress", setup.mode === "local" ? "Local" : "Remote"],
+				["Examples", includeExamples ? "Yes" : "No"]
+			]);
+			if (!yes && !await confirmProceed(FINAL_CONFIRMATION_TEXT)) {
+				fetchedRegistry.cleanup();
+				p.cancel("Setup cancelled.");
+				process.exit(0);
+			}
+			if (shouldPersistPm) persistPackageManagerField(cwd, pm);
+			const warnings = [];
 			const scaffolded = [];
-			for (const file of files) scaffolded.push({
-				file,
-				result: await scaffoldFile(cwd, file, {
-					force,
-					yes
-				})
-			});
-			writeGeneratedContract(cwd, serverDirRel);
-			const gitignore = ensureGitignored(cwd, ".env");
-			ensureGitignored(cwd, ".kizlo/");
+			let gitignore = "present";
+			const kizloSpec = `kizlo@${manifest.dependencies?.kizlo ?? `^${getVersion()}`}`;
+			if (await runChecklist([
+				{
+					title: `Installing kizlo with ${pm}`,
+					enabled: !hasKizlo,
+					run: async () => {
+						if (await runCommandAsync(addDependencyArgs(pm, kizloSpec), cwd, "ignore")) return "Installed kizlo";
+						warnings.push(`Install it yourself: ${addDependencyArgs(pm, kizloSpec).join(" ")}`);
+						throw new StepError("Could not install kizlo automatically", { fatal: false });
+					}
+				},
+				{
+					title: "Aligning dependencies",
+					run: (message) => alignDependencies(cwd, pm, pkg, manifest, message, warnings)
+				},
+				{
+					title: "Setting up local WordPress (first run downloads images, this can take a while)",
+					enabled: setup.mode === "local",
+					run: async () => {
+						try {
+							const warning = await provisionLocalWordPress(cwd, setup);
+							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(cwd, envKeys, setup, {
+						overwrite: overwriteEnv,
+						exampleTemplate: readEnvExample(entry.dir)
+					})
+				},
+				{
+					title: "Syncing settings to WordPress",
+					enabled: setup.mode === "remote" && Boolean(setup.wpUrl && setup.wpUsername && setup.wpPassword),
+					run: async () => {
+						warnings.push(...await syncRemote(setup));
+						return "Synced settings to WordPress";
+					}
+				},
+				{
+					title: "Scaffolding Kizlo files",
+					run: async () => {
+						for (const file of files) scaffolded.push({
+							file,
+							result: await scaffoldFile(cwd, file, {
+								force: overwritePaths.has(file.relPath),
+								yes: true
+							})
+						});
+						writeGeneratedContract(cwd, serverDirRel);
+						gitignore = ensureGitignored(cwd, ".env");
+						ensureGitignored(cwd, ".kizlo/");
+						const written = scaffolded.filter(({ result }) => result !== "kept").length;
+						return `Scaffolded ${written} file${written === 1 ? "" : "s"}`;
+					}
+				}
+			])) {
+				p.cancel("Setup failed — see the errors above.");
+				process.exit(1);
+			}
+			for (const warning of warnings) p.log.warn(warning);
 			for (const { file, result } of scaffolded) reportScaffold(file, result, yes);
-			applyProjectPatches(cwd, patchEntries(changesFor(manifest, "init")), manifest.conventions, scaffold);
-			for (const note of manifest.notes ?? []) {
+			applyProjectPatches(cwd, patchEntries(changesFor(manifest, "init")), manifest.config, scaffold);
+			for (const note of manifest.init.notes) {
 				const rendered = renderNote(note, setup.alias);
 				printManualStep(rendered.title, rendered.body);
 			}

package/dist/cli/daemon/config.js

@@ -130,7 +130,7 @@ async function resolveTestConfig(cwd) {
 		portExplicit: test.port !== void 0,
 		fixtures: test.fixtures ?? [],
 		credentialsPath: credentialsPath(cwd),
-		packageManager: test.packageManager ?? detectPackageManager(configDir) ?? "npm"
+		packageManager: test.packageManager ?? await detectPackageManager(configDir) ?? "npm"
 	};
 }
 /**

package/dist/cli/presets/source.js

@@ -54,7 +54,7 @@ function readMeta(manifestPath) {
 		const raw = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
 		return {
 			name: typeof raw.name === "string" && raw.name.trim() ? raw.name.trim() : void 0,
-			framework: typeof raw.framework === "string" && raw.framework.trim() ? raw.framework.trim() : void 0
+			id: typeof raw.id === "string" && raw.id.trim() ? raw.id.trim() : void 0
 		};
 	} catch {
 		return {};
@@ -69,7 +69,7 @@ function readMeta(manifestPath) {
 *   break the listing.
 * - A single template: a directory that is itself a template (`template.json` at its root) — the escape
 *   hatch for a community template shipped on its own, e.g. `--source github:acme/kizlo-astro-template`.
-*   Its id comes from the manifest's `framework` (a stable name that also matches what `init`'s detected
+*   Its id comes from the manifest's `id` (a stable name that also matches what `init`'s detected
 *   preset asks for), not the directory name, which for a downloaded repo is a random temp folder.
 *
 * Discovery is by scanning, not a hardcoded list, and the manifest is read only for its display fields
@@ -88,10 +88,10 @@ function listTemplates(registryDir) {
 	if (!fs.existsSync(registryDir)) return [];
 	if (isSingleTemplate(registryDir)) {
 		const meta = readMeta(path.join(registryDir, "template.json"));
-		const id = meta.framework ?? path.basename(registryDir);
+		const id = meta.id ?? path.basename(registryDir);
 		return [{
 			id,
-			label: meta.name ?? meta.framework ?? id,
+			label: meta.name ?? meta.id ?? id,
 			dir: registryDir
 		}];
 	}
@@ -104,17 +104,22 @@ function listTemplates(registryDir) {
 		const meta = readMeta(manifestPath);
 		entries.push({
 			id: dirent.name,
-			label: meta.name ?? meta.framework ?? dirent.name,
+			label: meta.name ?? meta.id ?? dirent.name,
 			dir
 		});
 	}
 	return entries.sort((a, b) => a.id.localeCompare(b.id));
 }
-/** A template's detection dependency list, read leniently so one bad manifest can't break detection. */
+/**
+* A template's detection package list — the `values` of every `dep` requirement under `init.requires`,
+* read leniently (raw JSON, no schema) so one malformed manifest can't break detection for the rest of a
+* registry. Full schema validation happens when the template is actually applied (`readManifest`).
+*/
 function readDetectDeps(templateDir) {
 	try {
-		const deps = JSON.parse(fs.readFileSync(path.join(templateDir, "template.json"), "utf8")).detect?.dependencies;
-		return Array.isArray(deps) ? deps.filter((name) => typeof name === "string") : [];
+		const requires = JSON.parse(fs.readFileSync(path.join(templateDir, "template.json"), "utf8")).init?.requires;
+		if (!Array.isArray(requires)) return [];
+		return requires.filter((req) => req?.kind === "dep" && Array.isArray(req.values)).flatMap((req) => req.values).filter((name) => typeof name === "string");
 	} catch {
 		return [];
 	}