create-upwind 0.2.0

package/dist/cli.js

@@ -0,0 +1,524 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import path from "node:path";
+import { cp, lstat, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+//#region src/package-manager.ts
+/**
+* Which package manager scaffolded this, and the install it runs.
+*
+* `pnpm create upwind`, `npm create upwind`, `yarn create upwind` and `bun create upwind` all reach
+* this same program, and the one thing they leave behind to say which they were is
+* `npm_config_user_agent`. A project installed with the manager its author started from is one whose
+* lockfile is the one they expect.
+*/
+const PACKAGE_MANAGERS = [
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun"
+];
+/** `pnpm/12.4.1 npm/? node/? linux x64` — the name is everything before the first slash. */
+function detectPackageManager() {
+	const [name] = (process.env["npm_config_user_agent"] ?? "").split("/", 1);
+	return PACKAGE_MANAGERS.find((manager) => manager === name) ?? "npm";
+}
+/** The application is on disk by now, whatever went wrong here; say so, and say what to do. */
+function refuse(manager, why) {
+	throw new Error(`${why}. The application is written; run \`${manager} install\` in it once you know why.`);
+}
+async function install(manager, cwd) {
+	const child = spawn(manager, ["install"], {
+		cwd,
+		stdio: "inherit",
+		shell: process.platform === "win32"
+	});
+	let code;
+	try {
+		[code] = await once(child, "exit");
+	} catch {
+		refuse(manager, `\`${manager}\` could not be run; it may not be installed`);
+	}
+	if (code !== 0) refuse(manager, `\`${manager} install\` failed`);
+}
+/** The two the bare word does not reach a project script through. */
+const NEEDS_RUN = /* @__PURE__ */ new Set(["bun", "npm"]);
+/**
+* How a developer runs one of the project's scripts with this manager.
+*
+* `npm dev` is not a command at all, and `bun build` is a different one: Bun's own bundler, which
+* answers a project's `build` script with "Missing entrypoints". Both take `run`. `pnpm` and `yarn`
+* pass an unknown word to the scripts, and `pnpm run dev` would only be longer.
+*/
+function runCommand(manager, script) {
+	return NEEDS_RUN.has(manager) ? `${manager} run ${script}` : `${manager} ${script}`;
+}
+//#endregion
+//#region src/args.ts
+/** At most one `--use-*`: two would be a question about which, and there is no good answer. */
+function packageManagerOf(values) {
+	const chosen = PACKAGE_MANAGERS.filter((manager) => values[`use-${manager}`] === true);
+	if (chosen.length > 1) throw new Error(`only one package manager can be asked for, and ${chosen.length} were`);
+	return chosen[0];
+}
+/** `--help` and `--version` are options here rather than words looked for in the arguments, so that
+* `create-upwind -- --help` makes a directory called `--help` the way `parseArgs` says it should. */
+function answerOf(values) {
+	if (values["help"] === true) return "help";
+	return values["version"] === true ? "version" : void 0;
+}
+function parseCreateRequest(args) {
+	const { values, positionals } = parseArgs({
+		args: [...args],
+		options: {
+			git: {
+				type: "boolean",
+				default: true
+			},
+			help: {
+				type: "boolean",
+				short: "h"
+			},
+			"skip-install": { type: "boolean" },
+			"use-bun": { type: "boolean" },
+			"use-npm": { type: "boolean" },
+			"use-pnpm": { type: "boolean" },
+			"use-yarn": { type: "boolean" },
+			version: {
+				type: "boolean",
+				short: "v"
+			}
+		},
+		allowNegative: true,
+		allowPositionals: true,
+		strict: true
+	});
+	const answer = answerOf(values);
+	if (answer === void 0 && positionals.length > 1) throw new Error(`one directory at most, and ${positionals.length} were given`);
+	return {
+		answer,
+		directory: positionals[0],
+		install: values["skip-install"] !== true,
+		git: values.git,
+		packageManager: answer === void 0 ? packageManagerOf(values) : void 0
+	};
+}
+//#endregion
+//#region src/git.ts
+/**
+* A first commit, where there is a repository to be made.
+*
+* Never fatal. A machine with no git, a git with no identity configured, a directory already inside
+* somebody's repository: none of those is a reason to have failed to scaffold an application, and
+* all of them are things a developer can see for themselves. A repository this started and could not
+* finish is removed again, so what is left is either a clean first commit or no `.git` at all.
+*/
+const FIRST_COMMIT = "Initial commit from create-upwind";
+/** Run git, quietly; `undefined` when git itself is not there. */
+async function git(args, cwd) {
+	const child = spawn("git", args, {
+		cwd,
+		stdio: "ignore"
+	});
+	try {
+		const [code] = await once(child, "exit");
+		return code ?? 1;
+	} catch {
+		return;
+	}
+}
+/** Is this directory already part of a repository? Then its history is not this program's to start. */
+async function insideRepository(cwd) {
+	return await git(["rev-parse", "--is-inside-work-tree"], cwd) === 0;
+}
+/**
+* Does the target already hold a checkout of its own? Then nothing here is this program's.
+*
+* `lstat`, not `stat`: a `.git` that is a symlink — dangling, or pointing at a repository somewhere
+* else — is still an entry this program did not put there. Following it would answer "nothing here"
+* for a broken one, and `git init` would then write through it, into a directory nobody named.
+*/
+async function hasGitEntry(target) {
+	try {
+		await lstat(path.join(target, ".git"));
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** True when a repository was made and committed to. */
+async function initRepository(target) {
+	if (await hasGitEntry(target) || await insideRepository(target)) return false;
+	if (await git([
+		"init",
+		"-b",
+		"main"
+	], target) !== 0) return false;
+	if ((await git(["add", "-A"], target) === 0 ? await git([
+		"commit",
+		"-m",
+		FIRST_COMMIT
+	], target) : void 0) === 0) return true;
+	try {
+		await rm(path.join(target, ".git"), {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+	return false;
+}
+//#endregion
+//#region src/version.ts
+/**
+* This scaffolder's own version, and what it asks for of the packages released beside it.
+*
+* `create-upwind@x.y.z` scaffolds `upwind@^x.y.z`: the two are published from one tag, which the
+* release verifies says the version every package says, so a scaffolder and the CLI it wires in are
+* always of the same generation. A version that cannot be read falls back to `latest` — a scaffolded
+* project that installs the newest is a better answer than one that installs nothing.
+*/
+const FALLBACK = "latest";
+async function ownRange() {
+	try {
+		const manifest = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+		if (typeof manifest === "object" && manifest !== null && "version" in manifest && typeof manifest.version === "string") return `^${manifest.version}`;
+		return FALLBACK;
+	} catch {
+		return FALLBACK;
+	}
+}
+/** The version this reports for `--version`, or nothing when its own manifest could not be read. */
+async function ownVersion() {
+	const range = await ownRange();
+	return range === FALLBACK ? void 0 : range.slice(1);
+}
+//#endregion
+//#region src/manifest.ts
+/**
+* The `package.json` a scaffolded project starts with.
+*
+* Written rather than shipped in the template, so the name is the directory's and the versions are
+* this release's. Two of them are the whole point of the file:
+*
+* - **`next`, `react`, `react-dom` are dependencies, not suggestions.** upwind runs the *project's*
+*   Next.js — `upwind dev` resolves it from the project and refuses to start without it — so an
+*   application that upwind can run is one that has Next.js of its own.
+* - **`upwind` and the adapter come from this release.** `create-upwind@x.y.z` asks for `^x.y.z` of
+*   both, and the release publishes them from one tag, so a scaffolded project is wired to the
+*   generation that scaffolded it.
+*
+* The rest is what Next.js 16 and Tailwind 4 need, and nothing else: no ESLint, no `src/`, no
+* component library. `create-next-app --empty` is the shape.
+*/
+/**
+* What the template is written against.
+*
+* `next` is a caret on the version this repository builds against, and stays inside
+* `SUPPORTED_NEXT_RANGE` (`@stayingupwind/adapter`'s `patches/versions.ts`), which is what the
+* adapter's patches are held to. A release that moves that range moves this line with it.
+*/
+const VERSIONS = {
+	"@tailwindcss/postcss": "^4.3.3",
+	"@types/node": "^24.13.4",
+	"@types/react": "^19.3.0",
+	"@types/react-dom": "^19.3.0",
+	next: "^16.3.6",
+	react: "^19.3.0",
+	"react-dom": "^19.3.0",
+	tailwindcss: "^4.3.3",
+	typescript: "^5.9.3"
+};
+async function writeManifest(target, name) {
+	const upwind = await ownRange();
+	const manifest = {
+		name,
+		version: "0.1.0",
+		private: true,
+		scripts: {
+			dev: "upwind dev",
+			build: "upwind build"
+		},
+		dependencies: {
+			next: VERSIONS.next,
+			react: VERSIONS.react,
+			"react-dom": VERSIONS["react-dom"]
+		},
+		devDependencies: {
+			"@stayingupwind/adapter": upwind,
+			"@tailwindcss/postcss": VERSIONS["@tailwindcss/postcss"],
+			"@types/node": VERSIONS["@types/node"],
+			"@types/react": VERSIONS["@types/react"],
+			"@types/react-dom": VERSIONS["@types/react-dom"],
+			tailwindcss: VERSIONS.tailwindcss,
+			typescript: VERSIONS.typescript,
+			upwind
+		}
+	};
+	await writeFile(path.join(target, "package.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+}
+//#endregion
+//#region src/name.ts
+/**
+* The name a scaffolded project takes, which is the directory it was asked for.
+*
+* npm's rules, as far as one matters here: the manifest this writes is `private`, so nothing will
+* ever publish it — but a name npm refuses is one that `npm install` inside the project refuses too,
+* and finding that out on the first install is worse than finding it out now.
+*
+* `validate-npm-package-name` is the package that knows all of them. It is not a dependency here for
+* the same reason nothing else is: this runs once, from a registry, in somebody else's shell.
+*/
+/** npm's own limit. */
+const MAX_LENGTH = 214;
+/** What an unscoped name may be made of, as the registry accepts it. */
+const ALLOWED = /^[a-z0-9._~-]+$/u;
+/** The two names npm refuses outright, whatever else is true of them. */
+const REFUSED = /* @__PURE__ */ new Set(["favicon.ico", "node_modules"]);
+/** What is wrong with `name` as a package name, or nothing when it is a fine one. */
+function nameProblem(name) {
+	if (name === "") return "is empty";
+	if (REFUSED.has(name)) return "is a name npm will not take, whatever is in the directory";
+	if (name.length > MAX_LENGTH) return `is longer than npm's ${MAX_LENGTH} characters`;
+	if (name !== name.toLowerCase()) return "has capital letters, which npm does not allow in a package name";
+	if (name.startsWith(".") || name.startsWith("_")) return "starts with a dot or an underscore, which npm does not allow in a package name";
+	if (!ALLOWED.test(name)) return "has characters npm does not allow in a package name (letters, digits, `.`, `-`, `_` and `~`)";
+}
+//#endregion
+//#region src/prompt.ts
+/**
+* The one question this asks.
+*
+* One, because there is one template: everything else a scaffolder usually asks — TypeScript, the
+* router, the bundler — is already decided by what upwind runs. A question with one possible answer
+* is a keystroke taken from someone who typed `pnpm create upwind` to get an application.
+*
+* Asked only of a terminal. `pnpm create upwind < /dev/null`, or the same from a script or a CI job,
+* takes the default rather than waiting for an answer that is never coming — a scaffolder that hangs
+* on a closed stdin is one that hangs a pipeline.
+*/
+/** The default is what an empty answer means, and Ctrl-D is the emptiest answer there is. */
+const NO_ANSWER = "";
+/** The answer an input that closed without one gives. */
+async function untilClosed(rl) {
+	await once(rl, "close");
+	return NO_ANSWER;
+}
+/**
+* The answer, or none.
+*
+* Ctrl-D does not answer the question, it abandons it: Node rejects the promise with an
+* `AbortError` — "Aborted with Ctrl+D" — rather than resolving it with nothing. Caught here, because
+* an input that has ended has no more answers to give, and the one this asks for has a default.
+*/
+async function askOnce(rl, prompt) {
+	try {
+		return await rl.question(prompt);
+	} catch {
+		return NO_ANSWER;
+	}
+}
+async function askDirectory(fallback) {
+	if (!process.stdin.isTTY) return fallback;
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		const trimmed = (await Promise.race([askOnce(rl, `Where should the application go? (${fallback}) `), untilClosed(rl)])).trim();
+		return trimmed === NO_ANSWER ? fallback : trimmed;
+	} finally {
+		rl.close();
+	}
+}
+//#endregion
+//#region src/template.ts
+/**
+* The application this copies, and what has to be renamed on the way out.
+*
+* `../templates/default/` reads the same from the sources a workspace links and from the module a
+* registry installs: both sit one directory below the package root, and `templates` travels with the
+* package (`files`).
+*
+* The template carries `gitignore` without its dot because **npm removes a `.gitignore` from every
+* tarball it packs**. A template that kept the dot would arrive with no ignore file at all, and the
+* first commit of every scaffolded project would carry `node_modules`. `create-next-app` renames the
+* same file for the same reason.
+*/
+const TEMPLATE = fileURLToPath(new URL("../templates/default/", import.meta.url));
+/** Entries that do not make a directory non-empty: a checkout and a Finder artefact. */
+const IGNORED_ENTRIES = /* @__PURE__ */ new Set([".DS_Store", ".git"]);
+/** Is this the error of a directory that is not there? Anything else is a directory that is. */
+function isMissing(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+/** What is already in the way, if anything: the names, so the message can say them. */
+async function conflictsIn(target) {
+	try {
+		return (await readdir(target)).filter((entry) => !IGNORED_ENTRIES.has(entry));
+	} catch (error) {
+		if (isMissing(error)) return [];
+		throw error;
+	}
+}
+async function copyTemplate(target) {
+	await cp(TEMPLATE, target, { recursive: true });
+	await rename(path.join(target, "gitignore"), path.join(target, ".gitignore"));
+}
+/**
+* The README, in the manager the project was made with.
+*
+* The template is written in pnpm because a file has to be written in something. A project installed
+* with npm has an npm lockfile, and a README that tells its reader to run pnpm tells them to install
+* it a second way — or, on a machine without pnpm, to run something that is not there.
+*/
+async function retellReadme(target, manager) {
+	if (manager === "pnpm") return;
+	const readme = path.join(target, "README.md");
+	const retold = (await readFile(readme, "utf8")).replaceAll("pnpm dev", () => runCommand(manager, "dev")).replaceAll("pnpm build", () => runCommand(manager, "build"));
+	await writeFile(readme, retold);
+}
+//#endregion
+//#region src/create.ts
+/**
+* One run: a directory with a Next.js application in it that upwind can run.
+*
+* The order is the order a developer would do it in. Everything that can be refused is refused
+* before anything is written — a name npm would not take, a directory with something in it — so a
+* run either leaves an application or leaves nothing.
+*
+* The install comes before the first commit so the lockfile is in it: the point of a lockfile is the
+* install somebody else does from it, and one that arrives a commit late is one that arrives after
+* the first person cloned it.
+*/
+const DEFAULT_DIRECTORY = "my-upwind-app";
+/** How many of the things in the way to name before saying "and others". */
+const CONFLICTS_SHOWN = 5;
+function refuseConflicts(target, conflicts) {
+	const shown = conflicts.slice(0, CONFLICTS_SHOWN).join(", ");
+	const rest = conflicts.length > CONFLICTS_SHOWN ? `, and ${conflicts.length - CONFLICTS_SHOWN} more` : "";
+	throw new Error(`${target} already has something in it (${shown}${rest})`);
+}
+/** How a single quote is written inside single quotes: close, escape one, open again. */
+const ESCAPED_QUOTE = String.raw`'\''`;
+/** What needs no quoting anywhere, plus the separator each shell writes a path with. */
+const PLAIN = process.platform === "win32" ? /^[\w+,.:=@\\-]+$/u : /^[\w+,./:=@-]+$/u;
+/**
+* A path the shell this was run from reads as one word, and as a path.
+*
+* Two things can go wrong with a next step somebody pastes. A path with a space in it is two
+* arguments — and `cmd.exe` does not read the single quotes a POSIX shell does, so the quoting has
+* to be the one the platform uses. And a relative path that begins with `-` is read as options by
+* every shell there is, which `./` settles.
+*
+* Two things are left, and both are `cmd.exe`'s alone. It expands `%NAME%` inside double quotes and
+* has no escape for it at the prompt, so a directory with a percent sign in its name prints a line
+* that reads as something else there. And a target on another drive needs `cd /d` there, which is
+* not a `cd` PowerShell accepts. Both read correctly in PowerShell, which is where a Windows
+* developer is more likely to be standing, and the alternative would be a line that is wrong in the
+* other shell instead.
+*/
+function shellWord(value) {
+	const safe = value.startsWith("-") ? `./${value}` : value;
+	if (PLAIN.test(safe)) return safe;
+	return process.platform === "win32" ? `"${safe}"` : `'${safe.replaceAll("'", () => ESCAPED_QUOTE)}'`;
+}
+function printNextSteps(options) {
+	const { manager, target } = options;
+	const where = path.relative(process.cwd(), target);
+	const dev = runCommand(manager, "dev");
+	console.log("");
+	console.log(`Created ${path.basename(target)}${options.committed ? " with a first commit" : ""}.`);
+	console.log("");
+	if (where !== "") console.log(`  cd ${shellWord(where)}`);
+	if (!options.installed) console.log(`  ${manager} install`);
+	console.log(`  ${dev}`);
+	console.log("");
+	console.log(`\`${dev}\` runs upwind in front of the project's own Next.js, and /__upwind is answered by`);
+	console.log(`upwind itself. \`${runCommand(manager, "build")}\` writes the deployment bundle under .ppr-cdn/.`);
+}
+async function create(request) {
+	const directory = request.directory ?? await askDirectory(DEFAULT_DIRECTORY);
+	const target = path.resolve(directory);
+	const name = path.basename(target);
+	const problem = nameProblem(name);
+	if (problem !== void 0) throw new Error(`\`${name}\` ${problem}`);
+	const conflicts = await conflictsIn(target);
+	if (conflicts.length > 0) refuseConflicts(target, conflicts);
+	const manager = request.packageManager ?? detectPackageManager();
+	console.log(`Creating ${name} in ${target}`);
+	await copyTemplate(target);
+	await retellReadme(target, manager);
+	await writeManifest(target, name);
+	if (request.install) {
+		console.log("");
+		await install(manager, target);
+	}
+	printNextSteps({
+		target,
+		manager,
+		committed: request.git && await initRepository(target),
+		installed: request.install
+	});
+}
+//#endregion
+//#region src/cli.ts
+/**
+* `create-upwind` — one command, one template, one question.
+*
+* `pnpm create upwind` (and `npm create upwind`, and the others) reach this program, and it writes a
+* Next.js application that upwind can run: Next.js and React as real dependencies, because upwind
+* runs the *project's* Next.js and has none of its own, the adapter that turns a build into a
+* deployment bundle, and Tailwind, because an application with no way to style it is a demonstration
+* rather than a start.
+*/
+const USAGE = `create-upwind — a Next.js application wired to upwind
+
+Usage
+  pnpm create upwind [directory]
+
+Options
+      --skip-install  Write the application, install nothing
+      --no-git        Do not make a first commit
+      --use-npm       Install with npm
+      --use-pnpm      Install with pnpm
+      --use-yarn      Install with yarn
+      --use-bun       Install with bun
+  -v, --version       Print create-upwind's version
+  -h, --help          Print this
+      --              Everything after this is the directory, even \`--help\`
+
+Asked for no directory, it asks for one — or takes \`my-upwind-app\` when nothing is there to ask.
+`;
+function fail(message, withUsage) {
+	console.error(`create-upwind: ${message}`);
+	if (withUsage) console.error(`\n${USAGE}`);
+	process.exit(1);
+}
+async function main() {
+	let request;
+	try {
+		request = parseCreateRequest(process.argv.slice(2));
+	} catch (error) {
+		fail(error instanceof Error ? error.message : String(error), true);
+	}
+	if (request.answer === "help") {
+		console.log(USAGE);
+		return;
+	}
+	if (request.answer === "version") {
+		console.log(await ownVersion() ?? "unknown");
+		return;
+	}
+	await create(request);
+}
+try {
+	await main();
+} catch (error) {
+	console.error(error instanceof Error ? `create-upwind: ${error.message}` : error);
+	process.exitCode = 1;
+}
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "create-upwind",
+  "version": "0.2.0",
+  "description": "`pnpm create upwind` — a Next.js application wired to upwind, ready to run.",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arkorlab/upwind.git",
+    "directory": "packages/create-upwind"
+  },
+  "bin": {
+    "create-upwind": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "templates",
+    "LICENSE-APACHE",
+    "LICENSE-MIT",
+    "NOTICE"
+  ],
+  "type": "module",
+  "devDependencies": {
+    "@types/node": "24.13.4",
+    "rolldown": "1.2.9",
+    "typescript": "5.9.3"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "node scripts/build.ts",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/args.ts

@@ -0,0 +1,70 @@
+import { parseArgs } from 'node:util';
+
+import { PACKAGE_MANAGERS, type PackageManager } from './package-manager.ts';
+
+/**
+ * What `create-upwind` understands.
+ *
+ * A directory, and three things about what to do after writing it. Everything a scaffolder usually
+ * asks about the application itself — the language, the router, the bundler — is decided by what
+ * upwind runs, so there is nothing to ask and nothing to flag.
+ */
+
+export interface CreateRequest {
+  /** What was asked for instead of an application, if anything. */
+  readonly answer: 'help' | 'version' | undefined;
+  /** Where the application goes; nothing when it is still to be asked for. */
+  readonly directory: string | undefined;
+  readonly install: boolean;
+  readonly git: boolean;
+  /** The manager to install with, or nothing to use the one this was started from. */
+  readonly packageManager: PackageManager | undefined;
+}
+
+/** At most one `--use-*`: two would be a question about which, and there is no good answer. */
+function packageManagerOf(values: Readonly<Record<string, unknown>>): PackageManager | undefined {
+  const chosen = PACKAGE_MANAGERS.filter((manager) => values[`use-${manager}`] === true);
+  if (chosen.length > 1) {
+    throw new Error(`only one package manager can be asked for, and ${chosen.length} were`);
+  }
+  return chosen[0];
+}
+
+/** `--help` and `--version` are options here rather than words looked for in the arguments, so that
+ * `create-upwind -- --help` makes a directory called `--help` the way `parseArgs` says it should. */
+function answerOf(values: Readonly<Record<string, unknown>>): CreateRequest['answer'] {
+  if (values['help'] === true) {
+    return 'help';
+  }
+  return values['version'] === true ? 'version' : undefined;
+}
+
+export function parseCreateRequest(args: readonly string[]): CreateRequest {
+  const { values, positionals } = parseArgs({
+    args: [...args],
+    options: {
+      git: { type: 'boolean', default: true },
+      help: { type: 'boolean', short: 'h' },
+      'skip-install': { type: 'boolean' },
+      'use-bun': { type: 'boolean' },
+      'use-npm': { type: 'boolean' },
+      'use-pnpm': { type: 'boolean' },
+      'use-yarn': { type: 'boolean' },
+      version: { type: 'boolean', short: 'v' },
+    },
+    allowNegative: true,
+    allowPositionals: true,
+    strict: true,
+  });
+  const answer = answerOf(values);
+  if (answer === undefined && positionals.length > 1) {
+    throw new Error(`one directory at most, and ${positionals.length} were given`);
+  }
+  return {
+    answer,
+    directory: positionals[0],
+    install: values['skip-install'] !== true,
+    git: values.git,
+    packageManager: answer === undefined ? packageManagerOf(values) : undefined,
+  };
+}

package/src/cli.ts

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import { parseCreateRequest } from './args.ts';
+import { create } from './create.ts';
+import { ownVersion } from './version.ts';
+
+/**
+ * `create-upwind` — one command, one template, one question.
+ *
+ * `pnpm create upwind` (and `npm create upwind`, and the others) reach this program, and it writes a
+ * Next.js application that upwind can run: Next.js and React as real dependencies, because upwind
+ * runs the *project's* Next.js and has none of its own, the adapter that turns a build into a
+ * deployment bundle, and Tailwind, because an application with no way to style it is a demonstration
+ * rather than a start.
+ */
+
+const USAGE = `create-upwind — a Next.js application wired to upwind
+
+Usage
+  pnpm create upwind [directory]
+
+Options
+      --skip-install  Write the application, install nothing
+      --no-git        Do not make a first commit
+      --use-npm       Install with npm
+      --use-pnpm      Install with pnpm
+      --use-yarn      Install with yarn
+      --use-bun       Install with bun
+  -v, --version       Print create-upwind's version
+  -h, --help          Print this
+      --              Everything after this is the directory, even \`--help\`
+
+Asked for no directory, it asks for one — or takes \`my-upwind-app\` when nothing is there to ask.
+`;
+
+function fail(message: string, withUsage: boolean): never {
+  console.error(`create-upwind: ${message}`);
+  if (withUsage) {
+    console.error(`\n${USAGE}`);
+  }
+  process.exit(1);
+}
+
+async function main(): Promise<void> {
+  let request;
+  try {
+    request = parseCreateRequest(process.argv.slice(2));
+  } catch (error) {
+    fail(error instanceof Error ? error.message : String(error), true);
+  }
+  if (request.answer === 'help') {
+    console.log(USAGE);
+    return;
+  }
+  if (request.answer === 'version') {
+    console.log((await ownVersion()) ?? 'unknown');
+    return;
+  }
+  await create(request);
+}
+
+try {
+  await main();
+} catch (error) {
+  console.error(error instanceof Error ? `create-upwind: ${error.message}` : error);
+  process.exitCode = 1;
+}