@tenkit/cli 0.1.1 → 0.2.0-next.0

package/README.md

@@ -1,27 +1,85 @@
 # @tenkit/cli
 
-Public Tenkit CLI implementation package.
+Public CLI implementation for creating Tenkit Expo projects.
 
-Most users should run Tenkit through the package-manager create entrypoint:
+Most users should run Tenkit through the create entrypoint:
 
 ```bash
 pnpm create tenkit@latest
 ```
 
-This package owns the real Public CLI implementation behind `create-tenkit`:
-parsing, prompts, create-flow orchestration, Template generation, dependency
-installation, git convenience policy, and final output.
+`@tenkit/cli` owns the real create flow behind `create-tenkit`: option parsing,
+prompts, Template generation, dependency installation, initial git setup, and
+final next steps.
 
-Tenkit creates Expo and React Native projects for white-label apps,
-multi-tenant products, App Variant builds, and Runtime Tenant experiences.
+## Highlights
 
-## Direct CLI
+- Create a generated Expo project from a selected Tenkit Setup Type.
+- Prompt for project name, Setup Type, App Variant customization, and Styling Choice.
+- Support `pnpm`, `npm`, `npx`, Bun, and `bunx` launchers.
+- Use the selected package manager for install commands, generated README
+  commands, and generated app-local commands.
+- Treat install and git failures as follow-up work so successful generation is
+  not hidden by convenience-step failures.
 
-The package exposes a `tenkit` binary for direct usage:
+## Usage
+
+```bash
+# Package-manager create entrypoints
+pnpm create tenkit@latest
+npm create tenkit@latest
+npx create-tenkit@latest
+bun create tenkit@latest
+bunx create-tenkit@latest
+```
+
+Direct binary usage is also available:
 
 ```bash
 tenkit --help
 ```
 
-For public project creation, prefer `pnpm create tenkit@latest` so the package
-manager resolves the create entrypoint correctly.
+## Common Options
+
+```bash
+tenkit --name studio-app --setup white-label --yes
+tenkit --name venue-network --setup runtime-tenants --yes
+tenkit --name franchise-app --setup generic-standalone --yes
+tenkit --name unistyles-app --setup white-label --styling unistyles --yes
+```
+
+```bash
+tenkit --name demo --setup runtime-tenants --yes --no-install --no-git
+```
+
+Supported public Setup Type slugs:
+
+```text
+white-label
+runtime-tenants
+generic-standalone
+```
+
+Supported Styling Option Values:
+
+```text
+bare
+uniwind
+unistyles
+```
+
+Bare remains the default when Styling is omitted or `--yes` accepts defaults.
+
+Override package-manager detection when needed:
+
+```bash
+tenkit --package-manager pnpm
+tenkit --package-manager npm
+tenkit --package-manager bun
+```
+
+## Package Boundary
+
+`@tenkit/cli` is the Public CLI implementation package. The `create-tenkit`
+package is a thin create entrypoint that delegates here. Template source,
+generation, and writer safety live in `@tenkit/template-generator`.

package/dist/index.mjs

@@ -4,8 +4,10 @@ import fs from "fs-extra";
 import { dirname, resolve } from "pathe";
 import { cancel, confirm, intro, isCancel, outro, select, text } from "@clack/prompts";
 import { Command } from "commander";
-import { SUPPORTED_PUBLIC_SETUP_SLUGS, formatSupportedGeneratedSetupTypes, generateProject, normalizeGeneratedSetupType, preflightWriteProject, writeProject } from "@tenkit/template-generator";
+import { SUPPORTED_PUBLIC_SETUP_SLUGS, formatSupportedGeneratedSetupTypes, generateProject, normalizeGeneratedAccentColor, normalizeGeneratedSetupType, preflightWriteProject, writeProject } from "@tenkit/template-generator";
+import { SUPPORTED_GENERATED_STYLING_CHOICES, normalizeGeneratedStylingChoice } from "@tenkit/template-generator/styling-definitions";
 import { spawn } from "node:child_process";
+import { deriveAppVariantIdentities, deriveAppVariantIdentity, derivePackageName, getGeneratedSetupTypeDefinition, normalizeProjectName, validatePackageName } from "@tenkit/template-generator/setup-type-definitions";
 //#region src/adapters/workspace.ts
 function isPackageJsonShape(value) {
 	return typeof value === "object" && value !== null;
@@ -36,9 +38,10 @@ function resolveRealPath(path) {
 }
 //#endregion
 //#region src/constants.ts
-const CLI_VERSION = "0.1.1";
+const CLI_VERSION = "0.2.0-next.0";
 const DEFAULT_PROJECT_NAME = "tenkit-app";
 const DEFAULT_PUBLIC_SETUP_SLUG = "white-label";
+const DEFAULT_STYLING_CHOICE = "bare";
 const PROMPT_CANCELLED = Symbol("prompt-cancelled");
 const SETUP_PROMPT_CHOICES = [
 	{
@@ -54,16 +57,33 @@ const SETUP_PROMPT_CHOICES = [
 		label: "Generic + Standalone Apps"
 	}
 ];
+const STYLING_PROMPT_LABELS = {
+	bare: "Bare",
+	uniwind: "Uniwind",
+	unistyles: "Unistyles"
+};
+const STYLING_PROMPT_CHOICES = SUPPORTED_GENERATED_STYLING_CHOICES.map((value) => ({
+	value,
+	label: STYLING_PROMPT_LABELS[value]
+}));
 function supportedSetupValues() {
 	return SUPPORTED_PUBLIC_SETUP_SLUGS;
 }
+function supportedStylingValues() {
+	return SUPPORTED_GENERATED_STYLING_CHOICES;
+}
 //#endregion
 //#region src/adapters/command-runner.ts
 function defaultRunCommand(command, args, cwd, options = {}) {
 	return new Promise((resolveCommand) => {
+		const stdio = options.stdio ?? "inherit";
 		const child = spawn(command, [...args], {
 			cwd,
-			stdio: options.stdio ?? "inherit"
+			env: options.env ? {
+				...process.env,
+				...options.env
+			} : process.env,
+			stdio
 		});
 		child.on("error", () => {
 			resolveCommand({
@@ -80,13 +100,6 @@ function defaultRunCommand(command, args, cwd, options = {}) {
 	});
 }
 //#endregion
-//#region src/errors.ts
-var CreateFlowCancelledError = class extends Error {
-	constructor() {
-		super("Create cancelled.");
-	}
-};
-//#endregion
 //#region src/adapters/git.ts
 async function isGitAvailable(runCommand, cwd) {
 	return (await runCommand("git", ["--version"], cwd, { stdio: "ignore" })).ok;
@@ -94,64 +107,46 @@ async function isGitAvailable(runCommand, cwd) {
 async function isInsideGitWorktree(runCommand, cwd) {
 	return (await runCommand("git", ["rev-parse", "--is-inside-work-tree"], cwd, { stdio: "ignore" })).ok;
 }
-async function resolveGitMode({ explicitGitMode, env, runCommand, targetDir }) {
-	if (explicitGitMode === false || explicitGitMode === "none") return {
-		mode: false,
+async function resolveGitMode({ enabled, runCommand, targetDir }) {
+	if (!enabled) return {
+		enabled: false,
 		skippedReason: "disabled"
 	};
 	if (!await isGitAvailable(runCommand, targetDir)) return {
-		mode: false,
+		enabled: false,
 		skippedReason: "git-unavailable"
 	};
-	if (await isInsideGitWorktree(runCommand, targetDir) && explicitGitMode === void 0) {
-		if (!env.isInteractive || env.isCi) return {
-			mode: false,
-			skippedReason: "nested-worktree"
-		};
-		const answer = await env.prompts.confirm({
-			message: "Initialize a nested git repository?",
-			initialValue: false
-		});
-		if (answer === PROMPT_CANCELLED) throw new CreateFlowCancelledError();
-		if (!answer) return {
-			mode: false,
-			skippedReason: "nested-worktree"
-		};
-	}
-	if (explicitGitMode === "init") return { mode: "init" };
-	return { mode: "commit" };
+	if (await isInsideGitWorktree(runCommand, targetDir)) return {
+		enabled: false,
+		skippedReason: "nested-worktree"
+	};
+	return { enabled: true };
 }
-async function prepareInitialGitSetup({ explicitGitMode, env, runCommand, probeDir }) {
+async function prepareInitialGitSetup({ enabled, runCommand, probeDir }) {
 	const gitPlan = await resolveGitMode({
-		explicitGitMode,
-		env,
+		enabled,
 		runCommand,
 		targetDir: probeDir
 	});
 	return { async run(targetDir) {
-		if (!gitPlan.mode) return {
+		if (!gitPlan.enabled) return {
 			gitInitialized: false,
 			gitCommitted: false,
 			gitSkippedReason: gitPlan.skippedReason,
 			gitFailed: false
 		};
-		const initResult = await runCommand("git", ["init"], targetDir);
+		const initResult = await runCommand("git", ["init"], targetDir, { stdio: "ignore" });
 		const gitInitialized = initResult.ok;
 		if (!initResult.ok) return {
 			gitInitialized,
 			gitCommitted: false,
 			gitFailed: true
 		};
-		if (gitPlan.mode === "init") return {
-			gitInitialized,
-			gitCommitted: false,
-			gitFailed: false
-		};
-		const commitResult = (await runCommand("git", ["add", "--all"], targetDir)).ok ? await runCommand("git", [
+		const commitResult = (await runCommand("git", ["add", "--all"], targetDir, { stdio: "ignore" })).ok ? await runCommand("git", [
 			"commit",
 			"-m",
 			"Initial commit"
-		], targetDir) : {
+		], targetDir, { stdio: "ignore" }) : {
 			ok: false,
 			code: 1
 		};
@@ -163,6 +158,35 @@ async function prepareInitialGitSetup({ explicitGitMode, env, runCommand, probeD
 	} };
 }
 //#endregion
+//#region src/create/package-manager.ts
+const SUPPORTED_PACKAGE_MANAGERS = [
+	"pnpm",
+	"npm",
+	"bun"
+];
+function normalizePackageManagerInput(packageManager) {
+	if (packageManager === void 0) return;
+	const normalized = packageManager.trim();
+	if (!normalized) throw new Error(`Package manager must be one of: ${SUPPORTED_PACKAGE_MANAGERS.join(", ")}.`);
+	if (isPublicCliPackageManager(normalized)) return normalized;
+	throw new Error(`Unsupported package manager ${JSON.stringify(packageManager)}. Expected one of: ${SUPPORTED_PACKAGE_MANAGERS.join(", ")}.`);
+}
+function detectPackageManager(userAgent) {
+	if (userAgent?.startsWith("pnpm")) return "pnpm";
+	if (userAgent?.startsWith("bun")) return "bun";
+	if (userAgent?.startsWith("npm")) return "npm";
+	return "pnpm";
+}
+function formatInstallCommand(packageManager) {
+	return `${packageManager} install`;
+}
+function formatRunCommand(packageManager, script) {
+	return `${packageManager} run ${script}`;
+}
+function isPublicCliPackageManager(value) {
+	return SUPPORTED_PACKAGE_MANAGERS.some((packageManager) => packageManager === value);
+}
+//#endregion
 //#region src/create/create-messages.ts
 function logFinalOutput(result, output) {
 	const projectShellArg = formatShellArg(result.projectName);
@@ -171,13 +195,13 @@ function logFinalOutput(result, output) {
 	output.log("");
 	output.log("Next steps:");
 	output.log(`- cd ${projectShellArg}`);
-	if (result.installFailed || !result.installed) output.log("- pnpm install");
-	output.log("- pnpm run android");
-	output.log("- pnpm run ios");
-	output.log("- pnpm run web");
+	if (result.installFailed || !result.installed) output.log(`- ${formatInstallCommand(result.packageManager)}`);
+	output.log(`- ${formatRunCommand(result.packageManager, "android")}`);
+	output.log(`- ${formatRunCommand(result.packageManager, "ios")}`);
+	output.log(`- ${formatRunCommand(result.packageManager, "web")}`);
 	if (result.installFailed) {
 		output.log("");
-		output.log("Dependency installation failed. Run pnpm install in the generated project.");
+		output.log(`Dependency installation failed. Run ${formatInstallCommand(result.packageManager)} in the generated project.`);
 	}
 	if (result.gitSkippedReason === "git-unavailable") {
 		output.log("");
@@ -195,33 +219,32 @@ function formatShellArg(value) {
 	return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 //#endregion
+//#region src/errors.ts
+var CreateFlowCancelledError = class extends Error {
+	constructor() {
+		super("Create cancelled.");
+	}
+};
+//#endregion
 //#region src/create/validation.ts
-function isPathSeparatorPresent(value) {
-	return value.includes("/") || value.includes("\\");
-}
 function validateProjectName(value) {
-	const projectName = value.trim();
-	if (projectName.length === 0) throw new Error("Project name is required.");
-	if (projectName === "." || projectName === "..") throw new Error("Project name must be a child folder name.");
-	if (isPathSeparatorPresent(projectName)) throw new Error("Project name must not contain path separators.");
-	if (/[\0-\x1F<>:"|?*]/.test(projectName)) throw new Error("Project name contains characters that are unsafe for a project folder.");
-	return projectName;
-}
-function slugifyPackageName(projectName) {
-	return projectName.trim().toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9._-]+/g, "-").replace(/^[._-]+|[._-]+$/g, "").replace(/-{2,}/g, "-");
+	try {
+		return normalizeProjectName(value);
+	} catch {
+		throw new Error("Project name must contain a usable Latin letter or number.");
+	}
 }
-function validatePackageName(value) {
-	const packageName = value.trim();
-	if (packageName.length === 0) throw new Error("Package name is required.");
-	if (packageName.length > 214) throw new Error("Package name must be 214 characters or fewer.");
-	if (packageName !== packageName.toLowerCase()) throw new Error("Package name must be lowercase.");
-	if (isPathSeparatorPresent(packageName)) throw new Error("Package name must not contain path separators.");
-	if (packageName.startsWith(".") || packageName.startsWith("_")) throw new Error("Package name must not start with \".\" or \"_\".");
-	if (!/^[a-z0-9][a-z0-9._-]*$/.test(packageName)) throw new Error("Package name must contain only lowercase letters, numbers, \".\", \"_\", and \"-\".");
-	return packageName;
+function normalizeAppVariantNameInput(value) {
+	return deriveAppVariantIdentity(value).displayName;
 }
-function derivePackageName(projectName) {
-	return validatePackageName(slugifyPackageName(projectName));
+function normalizeAppVariantAccentInput(value) {
+	const accent = value.trim();
+	const normalizedInput = accent.startsWith("#") ? accent : `#${accent}`;
+	try {
+		const normalizedAccent = normalizeGeneratedAccentColor(normalizedInput);
+		if (normalizedAccent) return normalizedAccent;
+	} catch {}
+	throw new Error(`Invalid App Variant Accent ${JSON.stringify(accent)}. Expected a six-digit hex color such as "#208AEF".`);
 }
 function normalizeSetupInput(setup, setupType) {
 	if (setup !== void 0 && setupType !== void 0 && setup !== setupType) throw new Error("Use either --setup or --setup-type, not both with different values.");
@@ -232,11 +255,26 @@ function normalizeSetupInput(setup, setupType) {
 		throw new Error(`Unsupported Setup Type ${JSON.stringify(selectedSetup)}. Expected ${formatSupportedGeneratedSetupTypes()}.`);
 	}
 }
-function parseGitMode(value) {
-	if (value === false) return false;
-	if (value === void 0) return;
-	if (value === "init" || value === "commit" || value === "none") return value;
-	throw new Error("Git mode must be one of: init, commit, none.");
+function normalizeStylingInput(value) {
+	try {
+		return normalizeGeneratedStylingChoice(value);
+	} catch {
+		throw new Error(`Unsupported Styling Choice ${JSON.stringify(value)}. Expected one of: ${supportedStylingValues().join(", ")}.`);
+	}
+}
+function normalizeAppVariantCustomization(setupType, appVariantNamesInput, appVariantAccentsInput) {
+	const definition = getGeneratedSetupTypeDefinition(setupType);
+	const appVariantNames = appVariantNamesInput === void 0 ? definition.appVariants.map(({ defaultName }) => defaultName) : appVariantNamesInput.split(",").map((name) => name.trim());
+	if (appVariantNames.some((name) => name.length === 0)) throw new Error("App Variant names must not contain empty items.");
+	if (appVariantNames.length !== definition.appVariants.length) throw new Error(`Expected exactly ${definition.appVariants.length} App Variant names for ${definition.publicSlug}.`);
+	deriveAppVariantIdentities(appVariantNames);
+	const rawAccents = appVariantAccentsInput === void 0 ? definition.appVariants.map(({ defaultAccent }) => defaultAccent) : appVariantAccentsInput.split(",").map((accent) => accent.trim());
+	if (rawAccents.some((accent) => accent.length === 0)) throw new Error("App Variant Accents must not contain empty items.");
+	if (rawAccents.length !== definition.appVariants.length) throw new Error(`Expected exactly ${definition.appVariants.length} App Variant Accents for ${definition.publicSlug}.`);
+	return {
+		appVariantNames,
+		appVariantAccents: rawAccents.map(normalizeAppVariantAccentInput)
+	};
 }
 //#endregion
 //#region src/create/resolve-create-options.ts
@@ -258,7 +296,66 @@ async function readProjectName(options, env) {
 		}
 	});
 	if (answer === PROMPT_CANCELLED) throw new CreateFlowCancelledError();
-	return validateProjectName(answer);
+	const projectName = validateProjectName(answer);
+	env.output.log(`Project folder/package: ${projectName}`);
+	return projectName;
+}
+async function readAppVariantCustomization(setupType, options, env) {
+	if (options.appVariantNamesInput !== void 0 || options.appVariantAccentsInput !== void 0) return normalizeAppVariantCustomization(setupType, options.appVariantNamesInput, options.appVariantAccentsInput);
+	if (options.yes || !env.isInteractive) return normalizeAppVariantCustomization(setupType, void 0, void 0);
+	const customize = await env.prompts.confirm({
+		message: "Customize App Variant names and Accent colors?",
+		initialValue: false
+	});
+	if (customize === PROMPT_CANCELLED) throw new CreateFlowCancelledError();
+	if (!customize) return normalizeAppVariantCustomization(setupType, void 0, void 0);
+	const definition = getGeneratedSetupTypeDefinition(setupType);
+	const appVariantNames = [];
+	const appVariantAccents = [];
+	for (const appVariant of definition.appVariants) {
+		const name = await env.prompts.text({
+			message: `App Variant name: ${appVariant.defaultName}`,
+			placeholder: appVariant.defaultName,
+			defaultValue: appVariant.defaultName,
+			validate(value) {
+				try {
+					normalizeAppVariantNameInput(value ?? "");
+					return;
+				} catch (error) {
+					return error instanceof Error ? error.message : String(error);
+				}
+			}
+		});
+		if (name === PROMPT_CANCELLED) throw new CreateFlowCancelledError();
+		const accent = await env.prompts.text({
+			message: `App Variant Accent: ${appVariant.defaultName}`,
+			placeholder: appVariant.defaultAccent,
+			defaultValue: appVariant.defaultAccent,
+			validate(value) {
+				try {
+					normalizeAppVariantAccentInput(value ?? "");
+					return;
+				} catch (error) {
+					return error instanceof Error ? error.message : String(error);
+				}
+			}
+		});
+		if (accent === PROMPT_CANCELLED) throw new CreateFlowCancelledError();
+		appVariantNames.push(name);
+		appVariantAccents.push(accent);
+	}
+	return normalizeAppVariantCustomization(setupType, appVariantNames.join(","), appVariantAccents.join(","));
+}
+async function readStylingChoice(options, env) {
+	if (options.styling !== void 0) return normalizeStylingInput(options.styling);
+	if (options.yes || !env.isInteractive) return DEFAULT_STYLING_CHOICE;
+	const answer = await env.prompts.select({
+		message: "Styling Choice",
+		initialValue: DEFAULT_STYLING_CHOICE,
+		options: STYLING_PROMPT_CHOICES
+	});
+	if (answer === PROMPT_CANCELLED) throw new CreateFlowCancelledError();
+	return normalizeStylingInput(answer);
 }
 async function readSetupType(options, env) {
 	if (options.setup !== void 0 || options.setupType !== void 0) return normalizeSetupInput(options.setup, options.setupType);
@@ -272,6 +369,35 @@ async function readSetupType(options, env) {
 	if (answer === PROMPT_CANCELLED) throw new CreateFlowCancelledError();
 	return normalizeGeneratedSetupType(answer);
 }
+async function readPackageManager(options, env) {
+	const detectedPackageManager = detectPackageManager(env.packageManagerUserAgent);
+	if (options.packageManager !== void 0) {
+		const packageManager = normalizePackageManagerInput(options.packageManager);
+		if (!packageManager) throw new Error("Package manager is required.");
+		return packageManager;
+	}
+	if (options.yes || !env.isInteractive) return detectedPackageManager;
+	const answer = await env.prompts.select({
+		message: "Package manager",
+		initialValue: detectedPackageManager,
+		options: SUPPORTED_PACKAGE_MANAGERS.map((packageManager) => ({
+			value: packageManager,
+			label: packageManager
+		}))
+	});
+	if (answer === PROMPT_CANCELLED) throw new CreateFlowCancelledError();
+	return answer;
+}
+async function readEnabledChoice({ explicitValue, message, options, env }) {
+	if (explicitValue !== void 0) return explicitValue;
+	if (options.yes || !env.isInteractive) return true;
+	const answer = await env.prompts.confirm({
+		message,
+		initialValue: true
+	});
+	if (answer === PROMPT_CANCELLED) throw new CreateFlowCancelledError();
+	return answer;
+}
 async function assertTargetIsSafe(targetDir) {
 	if (!await fs.pathExists(targetDir)) return;
 	if (!(await fs.stat(targetDir)).isDirectory()) throw new Error(`Generated project target ${targetDir} exists but is not a directory.`);
@@ -280,16 +406,35 @@ async function assertTargetIsSafe(targetDir) {
 async function resolveCreateOptions(options, env) {
 	const projectName = await readProjectName(options, env);
 	const setupType = await readSetupType(options, env);
+	const { appVariantNames, appVariantAccents } = await readAppVariantCustomization(setupType, options, env);
+	const stylingChoice = await readStylingChoice(options, env);
 	const packageName = options.packageName !== void 0 ? validatePackageName(options.packageName) : derivePackageName(projectName);
+	const packageManager = await readPackageManager(options, env);
+	const git = await readEnabledChoice({
+		explicitValue: options.git,
+		message: "Initialize Git?",
+		options,
+		env
+	});
+	const install = await readEnabledChoice({
+		explicitValue: options.install,
+		message: "Install dependencies?",
+		options,
+		env
+	});
 	const targetDir = resolve(env.cwd, projectName);
 	await assertTargetIsSafe(targetDir);
 	return {
 		projectName,
 		packageName,
 		setupType,
+		stylingChoice,
+		appVariantNames,
+		appVariantAccents,
 		targetDir,
-		install: options.install !== false,
-		git: parseGitMode(options.git),
+		packageManager,
+		install,
+		git,
 		dryRun: options.dryRun === true
 	};
 }
@@ -305,8 +450,12 @@ async function runCreateFlow(options, env) {
 	}));
 	const tree = generate({
 		setupType: resolvedOptions.setupType,
+		stylingChoice: resolvedOptions.stylingChoice,
+		appVariantAccents: resolvedOptions.appVariantAccents,
+		appVariantNames: resolvedOptions.appVariantNames,
 		projectName: resolvedOptions.projectName,
-		packageName: resolvedOptions.packageName
+		packageName: resolvedOptions.packageName,
+		packageManager: resolvedOptions.packageManager
 	});
 	if (resolvedOptions.dryRun) {
 		await preflightWriteProject({
@@ -321,6 +470,10 @@ async function runCreateFlow(options, env) {
 			projectName: resolvedOptions.projectName,
 			packageName: resolvedOptions.packageName,
 			setupType: resolvedOptions.setupType,
+			stylingChoice: resolvedOptions.stylingChoice,
+			appVariantAccents: resolvedOptions.appVariantAccents,
+			appVariantNames: resolvedOptions.appVariantNames,
+			packageManager: resolvedOptions.packageManager,
 			installed: false,
 			installFailed: false,
 			gitInitialized: false,
@@ -333,8 +486,7 @@ async function runCreateFlow(options, env) {
 	}
 	const gitProbeCwd = await fs.pathExists(resolvedOptions.targetDir) ? resolvedOptions.targetDir : env.cwd;
 	const gitSetup = await prepareInitialGitSetup({
-		explicitGitMode: resolvedOptions.git,
-		env,
+		enabled: resolvedOptions.git,
 		runCommand,
 		probeDir: gitProbeCwd
 	});
@@ -346,8 +498,8 @@ async function runCreateFlow(options, env) {
 	let installed = false;
 	let installFailed = false;
 	if (resolvedOptions.install) {
-		env.output.log("Installing dependencies with pnpm...");
-		const installResult = await runCommand("pnpm", ["install"], writeResult.targetDir);
+		env.output.log(`Installing dependencies with ${resolvedOptions.packageManager}...`);
+		const installResult = await runCommand(resolvedOptions.packageManager, ["install"], writeResult.targetDir, { stdio: "ignore" });
 		installed = installResult.ok;
 		installFailed = !installResult.ok;
 	}
@@ -358,6 +510,10 @@ async function runCreateFlow(options, env) {
 		projectName: resolvedOptions.projectName,
 		packageName: resolvedOptions.packageName,
 		setupType: resolvedOptions.setupType,
+		stylingChoice: resolvedOptions.stylingChoice,
+		appVariantAccents: resolvedOptions.appVariantAccents,
+		appVariantNames: resolvedOptions.appVariantNames,
+		packageManager: resolvedOptions.packageManager,
 		installed,
 		installFailed,
 		gitInitialized: gitResult.gitInitialized,
@@ -376,15 +532,19 @@ function normalizeCommanderOptions(options) {
 		packageName: options.packageName,
 		setup: options.setup,
 		setupType: options.setupType,
+		styling: options.styling,
+		appVariantNamesInput: options.variantNames,
+		appVariantAccentsInput: options.variantAccents,
+		packageManager: options.packageManager,
 		yes: options.yes,
 		install: options.install,
-		git: parseGitMode(options.git),
+		git: options.git,
 		dryRun: options.dryRun
 	};
 }
 function createProgram(env) {
 	const program = new Command();
-	program.name("tenkit").description("Create a generated Tenkit Expo project.").version(CLI_VERSION).allowExcessArguments(false).option("--name <name>", `project folder name, defaults to ${DEFAULT_PROJECT_NAME} with --yes`).option("--package-name <name>", "generated package.json name override").option("-s, --setup <setup>", `public Setup slug: ${supportedSetupValues().join(", ")}`).option("--setup-type <setupType>", "canonical Setup Type ID or public Setup slug").option("--yes", "skip prompts and accept defaults").option("--no-install", "skip dependency installation").option("--git <mode>", "git behavior: init, commit, none").option("--no-git", "skip git initialization").option("--dry-run", "validate options and print the create plan without writing files").configureOutput({
+	program.name("tenkit").description("Create a generated Tenkit Expo project.").version(CLI_VERSION).allowExcessArguments(false).option("--name <name>", `project folder name, defaults to ${DEFAULT_PROJECT_NAME} with --yes`).option("--package-name <name>", "generated package.json name override").option("-s, --setup <setup>", `public Setup slug: ${supportedSetupValues().join(", ")}`).option("--setup-type <setupType>", "canonical Setup Type ID or public Setup slug").option("--styling <styling>", `Styling Choice: ${supportedStylingValues().join(", ")}`).option("--variant-names <names>", "ordered comma-separated App Variant names").option("--variant-accents <colors>", "ordered comma-separated App Variant Accent colors").option("--package-manager <manager>", `install and generated command package manager: ${SUPPORTED_PACKAGE_MANAGERS.join(", ")}`).option("--yes", "skip prompts and accept defaults").option("--install", "install dependencies").option("--no-install", "skip dependency installation").option("--git", "initialize Git and create Initial commit").option("--no-git", "skip git initialization").option("--dry-run", "validate options and print the create plan without writing files").configureOutput({
 		writeOut: (message) => env.output.log(message.trimEnd()),
 		writeErr: (message) => env.output.error(message.trimEnd())
 	}).exitOverride().showHelpAfterError().action(async (options) => {
@@ -399,23 +559,28 @@ function createProgram(env) {
 function createPromptAdapter() {
 	return {
 		async text(options) {
+			const { defaultValue, validate, ...promptOptions } = options;
 			const answer = await text({
-				...options,
+				...promptOptions,
 				validate(value) {
-					return options.validate(value);
+					return validate(value === "" || value === void 0 ? defaultValue : value);
 				}
 			});
-			return isCancel(answer) ? PROMPT_CANCELLED : String(answer);
+			return isCancel(answer) ? PROMPT_CANCELLED : answer === "" || answer === void 0 ? defaultValue : String(answer);
 		},
 		async select(options) {
 			const answer = await select({
-				...options,
+				message: options.message,
+				initialValue: options.initialValue,
 				options: options.options.map((option) => ({
 					value: option.value,
 					label: option.label
 				}))
 			});
-			return isCancel(answer) ? PROMPT_CANCELLED : answer;
+			if (isCancel(answer)) return PROMPT_CANCELLED;
+			const selectedOption = options.options.find((option) => option.value === answer);
+			if (!selectedOption) throw new Error(`Prompt returned unsupported selection ${JSON.stringify(answer)}.`);
+			return selectedOption.value;
 		},
 		async confirm(options) {
 			const answer = await confirm(options);
@@ -439,7 +604,7 @@ async function main(argv = process.argv.slice(2), io = process) {
 		cwd: process.env.INIT_CWD ?? process.cwd(),
 		workspaceRoot,
 		isInteractive: io.stdin.isTTY === true && io.stdout.isTTY === true,
-		isCi: process.env.CI === "true",
+		packageManagerUserAgent: process.env.npm_config_user_agent,
 		output,
 		prompts: createPromptAdapter()
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenkit/cli",
-  "version": "0.1.1",
+  "version": "0.2.0-next.0",
   "description": "Public Tenkit CLI implementation package.",
   "license": "MIT",
   "homepage": "https://github.com/brilliantinsane/tenkit#readme",
@@ -41,12 +41,13 @@
     "commander": "^15.0.0",
     "fs-extra": "^11.3.5",
     "pathe": "^2.0.3",
-    "@tenkit/template-generator": "0.1.1"
+    "@tenkit/template-generator": "0.2.0-next.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^25.9.3",
     "tsdown": "^0.22.3",
+    "tsx": "^4.22.4",
     "typescript": "~6.0.3",
     "vitest": "^4.1.9"
   },
@@ -61,6 +62,7 @@
     "build": "pnpm -F @tenkit/template-generator build && tsdown src/index.ts --format esm --dts",
     "test": "vitest run",
     "typecheck": "tsc --noEmit --pretty false",
+    "verify:matrix": "pnpm -F @tenkit/template-generator build && tsx scripts/verify-generation-matrix.ts",
     "pack:dry-run": "pnpm pack --dry-run"
   }
 }