create-chanom-app 0.0.0

package/README.md

@@ -0,0 +1,86 @@
+# create-chanom-app
+
+Scaffold a Vite + React + TypeScript app, wired to the [chanom](https://github.com/peeranat-dan/chanom) shared configs, with a couple of prompts.
+
+## Usage
+
+Run it directly, no install needed:
+
+```sh
+npm create chanom-app@latest
+# or
+pnpm create chanom-app
+```
+
+Pass a directory to skip the name prompt:
+
+```sh
+pnpm create chanom-app my-app
+```
+
+Scaffold into the current directory with `.`:
+
+```sh
+pnpm create chanom-app .
+```
+
+## Prompts
+
+Run with no flags, the CLI walks you through:
+
+1. **Project name** - the target directory (kebab-cased). Defaults to `my-chanom-app`.
+2. **Initialize a git repository?** - `git init` plus an initial commit.
+3. **Add commit hooks?** - husky + lint-staged + commitlint (only asked when git is enabled).
+4. **Install dependencies now?** - runs `<pm> install` after scaffolding.
+
+Every prompt has a matching flag so you can pre-answer any of them (or all, with `--yes`).
+
+## Options
+
+| Flag                          | What it does                                              |
+| ----------------------------- | --------------------------------------------------------- |
+| `[directory]`                 | Target directory / project name (prompted if omitted)     |
+| `--git` / `--no-git`          | Initialize a git repository (default: yes)                |
+| `--commit-hooks`              | Add husky + lint-staged + commitlint (requires git)       |
+| `--no-commit-hooks`           | Skip the commit-hooks topping                             |
+| `--install` / `--no-install`  | Install dependencies after scaffolding (default: install) |
+| `--pm <pnpm\|npm\|yarn\|bun>` | Package manager to record (default: detected)             |
+| `-y`, `--yes`                 | Accept all defaults, no prompts (CI-friendly)             |
+| `--help`                      | Show help                                                 |
+| `--version`                   | Show the version                                          |
+
+`--no-git --commit-hooks` is rejected: husky needs a repo to install into.
+
+The package manager is detected from the invoking user agent (falling back to `pnpm`); `--pm` overrides it and is recorded in the generated `package.json` `packageManager` field.
+
+### Non-interactive
+
+```sh
+pnpm create chanom-app my-app --yes --no-install
+```
+
+`--yes` accepts every default without prompting, so scaffolding runs unattended in CI.
+
+## What gets generated
+
+A minimal Vite + React + TS app wired to the chanom shared configs:
+
+- `package.json` - dependencies pinned to the versions the scaffolder bundles, plus `dev` / `build` / `preview` / `lint` / `format` / `format:check` / `test` / `test:watch` scripts
+- `vite.config.ts` - using `@vitejs/plugin-react` and [`@chanom/vite-config`](../vite-config)
+- `tsconfig.json` - extending `@tsconfig/vite-react`
+- `oxlint.config.ts` / `oxfmt.config.ts` - re-exporting the [`@chanom/dev-config`](../dev-config) presets
+- `vitest.config.ts` and a sample `src/app.test.tsx`
+- `src/` - `main.tsx`, `app.tsx`, `index.css`, and type declarations
+- `index.html`, `.gitignore`, and a starter `README.md`
+
+With the **commit-hooks** topping, it also adds husky, lint-staged, and commitlint as dev dependencies plus their config files (`.husky/pre-commit`, `.husky/commit-msg`, `.lintstagedrc.json`, `.commitlintrc.json`). The hooks materialize on the first install via the generated `prepare: "husky"` script.
+
+## Development
+
+```sh
+pnpm build      # bundle with tsdown (copies templates/ into dist/)
+pnpm test       # run vitest once
+pnpm test:watch # run vitest in watch mode
+```
+
+Most files in `templates/` are copied byte-for-byte into every generated app. The README, `src/app.tsx`, and `src/app.test.tsx` have their app-name placeholders replaced; files whose contents are fully computed (`package.json`, `vite.config.ts`, `tsconfig.json`, `index.html`) are rendered by the generators in `src/generate/`.

package/dist/index.js

@@ -0,0 +1,827 @@
+#!/usr/bin/env node
+import { Command, CommandExecutor, FileSystem, Path } from "@effect/platform";
+import { Data, Effect, Layer, LogLevel, Logger, Option, Stream } from "effect";
+import * as clack from "@clack/prompts";
+import pc from "picocolors";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { join } from "node:path";
+//#region ../internal/src/domain/package-manager.ts
+/** How to run a locally installed binary with each package manager. */
+const PM_EXEC = {
+	pnpm: ["pnpm", "exec"],
+	npm: [
+		"npx",
+		"--no",
+		"--"
+	],
+	yarn: ["yarn"],
+	bun: ["bunx"]
+};
+const KNOWN_PMS = [
+	"pnpm",
+	"yarn",
+	"bun",
+	"npm"
+];
+/** Parses the `packageManager` field of package.json, e.g. `pnpm@11.9.0`. */
+function parsePmField(field) {
+	if (!field) return void 0;
+	const name = field.split("@")[0];
+	return KNOWN_PMS.find((pm) => pm === name);
+}
+/** Parses the `npm_config_user_agent` environment variable, e.g. `pnpm/11.9.0 npm/? node/v22`. */
+function parsePmUserAgent(agent) {
+	if (!agent) return void 0;
+	return KNOWN_PMS.find((pm) => agent.startsWith(pm));
+}
+/** The `packageManager` field wins over the user agent, which wins over the fallback. */
+function resolvePm(hints) {
+	return parsePmField(hints.packageManagerField) ?? parsePmUserAgent(hints.userAgent) ?? hints.fallback ?? "pnpm";
+}
+//#endregion
+//#region ../internal/src/services/command-runner.ts
+const collectText = (stream) => stream.pipe(Stream.decodeText(), Stream.mkString);
+/**
+* Low-level process execution. Everything that shells out (git, package
+* managers, husky) goes through this service so commands can be stubbed in tests.
+*/
+var CommandRunner = class extends Effect.Service()("internal/CommandRunner", { effect: Effect.gen(function* () {
+	const executor = yield* CommandExecutor.CommandExecutor;
+	const make = (cmd, args, cwd) => Command.make(cmd, ...args).pipe(Command.workingDirectory(cwd));
+	const traced = (cmd, args, cwd, effect) => Effect.logDebug(`spawning \`${cmd} ${args.join(" ")}\` in ${cwd}`).pipe(Effect.andThen(effect), Effect.tap((code) => Effect.logDebug(`\`${cmd} ${args.join(" ")}\` exited with ${code}`)));
+	const capture = (cmd, args, cwd) => Effect.scoped(Effect.gen(function* () {
+		yield* Effect.logDebug(`spawning \`${cmd} ${args.join(" ")}\` in ${cwd}`);
+		const proc = yield* executor.start(make(cmd, args, cwd));
+		const [exitCode, stdout, stderr] = yield* Effect.all([
+			proc.exitCode,
+			collectText(proc.stdout),
+			collectText(proc.stderr)
+		], { concurrency: 3 });
+		yield* Effect.logDebug(`\`${cmd} ${args.join(" ")}\` exited with ${exitCode}`);
+		return {
+			exitCode,
+			stdout: stdout.trim(),
+			stderr: stderr.trim()
+		};
+	}));
+	const exitCode = (cmd, args, cwd) => traced(cmd, args, cwd, make(cmd, args, cwd).pipe(Command.exitCode, Effect.provideService(CommandExecutor.CommandExecutor, executor)));
+	const execInherit = (cmd, args, cwd) => traced(cmd, args, cwd, make(cmd, args, cwd).pipe(Command.stdout("inherit"), Command.stderr("inherit"), Command.exitCode, Effect.provideService(CommandExecutor.CommandExecutor, executor)));
+	return {
+		/** Runs a command silently and collects its exit code and trimmed output. */
+		capture,
+		/** Runs a command silently and returns only its exit code. */
+		exitCode,
+		/** Runs a command with stdout/stderr forwarded to the user's terminal. */
+		execInherit
+	};
+}) }) {};
+//#endregion
+//#region ../internal/src/services/git.ts
+/** Git operations, built on top of {@link CommandRunner}. */
+var Git = class extends Effect.Service()("internal/Git", { effect: Effect.gen(function* () {
+	const runner = yield* CommandRunner;
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const run = (args, cwd) => runner.capture("git", args, cwd).pipe(Effect.map(({ exitCode, stdout, stderr }) => ({
+		ok: exitCode === 0,
+		stdout,
+		stderr
+	})));
+	const exitOk = (args, cwd) => runner.exitCode("git", args, cwd).pipe(Effect.map((code) => code === 0));
+	return {
+		init: (cwd) => run(["init"], cwd),
+		stageAll: (cwd) => run(["add", "."], cwd),
+		commit: (cwd, message) => run([
+			"commit",
+			"-m",
+			message
+		], cwd),
+		hasIdentity: (cwd) => exitOk(["var", "GIT_COMMITTER_IDENT"], cwd),
+		setLocalIdentity: (cwd, name, email) => run([
+			"config",
+			"user.name",
+			name
+		], cwd).pipe(Effect.andThen(() => run([
+			"config",
+			"user.email",
+			email
+		], cwd)), Effect.asVoid),
+		hasStagedChanges: (cwd) => exitOk([
+			"diff",
+			"--cached",
+			"--quiet"
+		], cwd).pipe(Effect.map((clean) => !clean)),
+		/**
+		* True when `cwd` is anywhere inside a git work tree — a `.git` folder
+		* check would miss subdirectories (e.g. workspace packages) and lead to
+		* nested `git init` calls.
+		*/
+		isRepo: (cwd) => exitOk(["rev-parse", "--is-inside-work-tree"], cwd),
+		/** Path of `cwd` relative to the work-tree root: empty at the root, `None` outside a repository. */
+		prefix: (cwd) => run(["rev-parse", "--show-prefix"], cwd).pipe(Effect.map((result) => result.ok ? Option.some(result.stdout) : Option.none())),
+		/** Absolute path of the work-tree root, or `None` outside a repository. */
+		root: (cwd) => run(["rev-parse", "--show-toplevel"], cwd).pipe(Effect.map((result) => result.ok ? Option.some(result.stdout) : Option.none())),
+		writeGitignore: (cwd, contents = "node_modules\n") => fs.writeFileString(path.join(cwd, ".gitignore"), contents),
+		readGitignore: (cwd) => fs.readFileString(path.join(cwd, ".gitignore"))
+	};
+}) }) {};
+//#endregion
+//#region ../internal/src/services/prompter.ts
+var Cancelled = class extends Data.TaggedError("Cancelled") {};
+const guardCancel = (make) => Effect.promise(make).pipe(Effect.filterOrFail((result) => typeof result !== "symbol", () => new Cancelled()));
+/**
+* All terminal interaction (prompts, spinners, log messages). Commands never
+* touch @clack/prompts directly, so tests can script answers and capture output.
+*/
+var Prompter = class extends Effect.Service()("internal/Prompter", { succeed: {
+	intro: (message) => Effect.sync(() => clack.intro(message)),
+	outro: (message) => Effect.sync(() => clack.outro(message)),
+	warn: (message) => Effect.sync(() => clack.log.warn(message)),
+	error: (message) => Effect.sync(() => clack.log.error(message)),
+	info: (message) => Effect.sync(() => clack.log.info(message)),
+	/** Prints a message with no icon or styling (help text, plan summaries). */
+	message: (message) => Effect.sync(() => clack.log.message(message)),
+	debug: (message) => Effect.sync(() => clack.log.message(pc.dim(message))),
+	text: (params) => guardCancel(() => clack.text({
+		message: params.message,
+		placeholder: params.placeholder,
+		defaultValue: params.defaultValue,
+		initialValue: params.initialValue,
+		validate: params.validate
+	})),
+	confirm: (params) => guardCancel(() => clack.confirm({
+		message: params.message,
+		initialValue: params.initialValue ?? true
+	})),
+	select: (params) => guardCancel(() => clack.select({
+		message: params.message,
+		options: [...params.options]
+	})),
+	multiselect: (params) => guardCancel(() => clack.multiselect({
+		message: params.message,
+		options: [...params.options],
+		required: params.required ?? false
+	})),
+	spinner: (message) => Effect.sync(() => {
+		const s = clack.spinner();
+		s.start(message);
+		return { stop: (stopMessage) => Effect.sync(() => s.stop(stopMessage)) };
+	})
+} }) {};
+//#endregion
+//#region src/bundled-versions.ts
+const depVersions = {
+	"react": "19.2.8",
+	"react-dom": "19.2.8",
+	"@vitejs/plugin-react": "6.0.4",
+	"@tsconfig/vite-react": "8.1.1",
+	"@types/react": "19.2.17",
+	"@types/react-dom": "19.2.3",
+	"typescript": "6.0.3",
+	"vite": "8.1.0",
+	"vitest": "3.2.6",
+	"@vitest/coverage-v8": "3.2.6",
+	"jsdom": "30.0.0",
+	"@testing-library/react": "16.3.2",
+	"@testing-library/jest-dom": "7.0.0",
+	"oxlint": "1.73.0",
+	"oxlint-tsgolint": "0.24.0",
+	"oxfmt": "0.58.0",
+	"husky": "9.1.7",
+	"lint-staged": "17.0.8",
+	"@commitlint/cli": "21.2.0",
+	"@commitlint/config-conventional": "21.2.0",
+	"@chanom/dev-config": "0.0.3",
+	"@chanom/vite-config": "0.1.0"
+};
+/** This package's own version, for `--version`. */
+const pkgVersion = "0.0.0";
+//#endregion
+//#region src/domain/args.ts
+const PACKAGE_MANAGERS = [
+	"pnpm",
+	"npm",
+	"yarn",
+	"bun"
+];
+const isPackageManager = (value) => PACKAGE_MANAGERS.includes(value);
+/**
+* Parses the CLI arguments, returning either the resolved flags or a
+* user-facing error message. Every flag mirrors an interactive prompt; the
+* contradictory `--no-git --commit-hooks` pair is rejected here rather than
+* silently reconciled (husky needs a repo to install into).
+*/
+function parseArgs(argv) {
+	const args = {
+		yes: false,
+		help: false,
+		version: false
+	};
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		switch (arg) {
+			case "-y":
+			case "--yes":
+				args.yes = true;
+				break;
+			case "-h":
+			case "--help":
+				args.help = true;
+				break;
+			case "--version":
+				args.version = true;
+				break;
+			case "--git":
+				args.git = true;
+				break;
+			case "--no-git":
+				args.git = false;
+				break;
+			case "--commit-hooks":
+				args.commitHooks = true;
+				break;
+			case "--no-commit-hooks":
+				args.commitHooks = false;
+				break;
+			case "--install":
+				args.install = true;
+				break;
+			case "--no-install":
+				args.install = false;
+				break;
+			case "--pm": {
+				const value = argv[++i];
+				if (value === void 0) return {
+					ok: false,
+					message: "--pm requires a value."
+				};
+				if (!isPackageManager(value)) return {
+					ok: false,
+					message: `Unknown package manager "${value}". Use one of: ${PACKAGE_MANAGERS.join(", ")}.`
+				};
+				args.pm = value;
+				break;
+			}
+			default:
+				if (arg.startsWith("-")) return {
+					ok: false,
+					message: `Unknown option: ${arg}`
+				};
+				if (args.directory !== void 0) return {
+					ok: false,
+					message: `Unexpected extra argument: ${arg}`
+				};
+				args.directory = arg;
+		}
+	}
+	if (args.git === false && args.commitHooks === true) return {
+		ok: false,
+		message: "--commit-hooks requires a git repo. Remove --no-git or --commit-hooks."
+	};
+	return {
+		ok: true,
+		args
+	};
+}
+/**
+* Validates a project name / target directory. Returns an error message to
+* reject it, or `undefined` when it is acceptable. `.` (scaffold into the
+* current directory) is allowed.
+*/
+function validateProjectName(name) {
+	if (name.trim() === "") return "Please enter a project name.";
+	if (name === ".") return void 0;
+	if (!/^[a-z0-9._-]+$/i.test(name)) return "Use letters, numbers, dots, dashes, and underscores only.";
+	if (name.startsWith(".")) return "Name cannot start with a dot.";
+}
+//#endregion
+//#region src/domain/project-name.ts
+/**
+* Converts a project name to the lowercase kebab-case format expected for an
+* unscoped npm package name.
+*/
+function toKebabCase(name) {
+	return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[._\s-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+//#endregion
+//#region src/domain/contribution.ts
+const dedupe = (values) => [...new Set(values)];
+/**
+* Folds contributions in order into a single value. Package names, vite imports,
+* and plugins are concatenated then de-duplicated (first occurrence wins its
+* position); scripts merge with later contributions overriding earlier keys;
+* files de-duplicate by path (first writer wins).
+*/
+function mergeContributions(contributions) {
+	const filesByPath = /* @__PURE__ */ new Map();
+	for (const contribution of contributions) for (const file of contribution.files) if (!filesByPath.has(file.path)) filesByPath.set(file.path, file);
+	return {
+		dependencies: dedupe(contributions.flatMap((c) => c.dependencies)),
+		devDependencies: dedupe(contributions.flatMap((c) => c.devDependencies)),
+		scripts: contributions.reduce((acc, c) => ({
+			...acc,
+			...c.scripts
+		}), {}),
+		viteImports: dedupe(contributions.flatMap((c) => c.viteImports)),
+		vitePlugins: dedupe(contributions.flatMap((c) => c.vitePlugins)),
+		files: [...filesByPath.values()]
+	};
+}
+//#endregion
+//#region src/generate/app-template.ts
+/**
+* Replaces the placeholder app name in the generated component and its test.
+* The app name is normalized before it reaches this renderer.
+*/
+function renderAppTemplate(template, appName) {
+	return template.replaceAll("my-app", appName);
+}
+//#endregion
+//#region src/generate/index-html.ts
+/**
+* Renders `index.html` with the app name as its `<title>`. This is the one file
+* whose content varies by project name, so it is generated rather than copied;
+* the project name is validated to `[a-z0-9._-]`, so no HTML escaping is needed.
+*/
+function renderIndexHtml(appName) {
+	return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${appName}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"><\/script>
+  </body>
+</html>
+`;
+}
+//#endregion
+//#region src/domain/versions.ts
+/**
+* Pinned version for `name`, throwing when it is absent. Missing keys are a
+* build/catalog bug (the strict build-time reader should have already caught
+* them), never a reason to fall back to a range or `latest`.
+*/
+function resolveVersion(versions, name) {
+	const version = versions[name];
+	if (version === void 0) throw new Error(`No pinned version for "${name}". The dependency version map is incomplete.`);
+	return version;
+}
+//#endregion
+//#region src/generate/package-json.ts
+/** Resolves each name to its exact pinned version, sorted for deterministic output. */
+function toDependencyMap(names, versions) {
+	const map = {};
+	for (const name of [...names].sort()) map[name] = resolveVersion(versions, name);
+	return map;
+}
+/**
+* Renders the generated `package.json` as a string. Every dependency is pinned
+* exact from the injected catalog versions; a missing version throws rather
+* than emitting a range (see {@link resolveVersion}).
+*
+* The pnpm build allow-list lives in `pnpm-workspace.yaml`, not here: pnpm no
+* longer reads `pnpm.onlyBuiltDependencies` from `package.json` (see
+* {@link buildPnpmWorkspace}).
+*/
+function buildPackageJson(input) {
+	const pkg = {
+		name: toKebabCase(input.appName),
+		version: "0.0.0",
+		private: true,
+		type: "module",
+		...input.packageManager === void 0 ? {} : { packageManager: input.packageManager },
+		scripts: input.contribution.scripts,
+		dependencies: toDependencyMap(input.contribution.dependencies, input.versions),
+		devDependencies: toDependencyMap(input.contribution.devDependencies, input.versions)
+	};
+	return JSON.stringify(pkg, null, 2) + "\n";
+}
+//#endregion
+//#region src/generate/pnpm-workspace.ts
+/**
+* Build scripts pnpm must be told to run for the generated app. pnpm v10 blocks
+* every dependency lifecycle script unless it is allow-listed; esbuild (pulled
+* in by the Vite baseline) needs its postinstall to compile its native binary,
+* so without this the very first `pnpm install` aborts with ERR_PNPM_IGNORED_BUILDS.
+*
+* This lives in `pnpm-workspace.yaml` rather than a `package.json` `pnpm` field:
+* pnpm no longer reads `pnpm.onlyBuiltDependencies` from `package.json` and warns
+* when it is present. A standalone (non-workspace) project still reads the
+* setting from `pnpm-workspace.yaml`.
+*/
+const onlyBuiltDependencies = ["esbuild"];
+const allowBuilds = ["esbuild"];
+/** Renders the generated `pnpm-workspace.yaml` as a string. */
+function buildPnpmWorkspace() {
+	return [
+		"onlyBuiltDependencies:",
+		...onlyBuiltDependencies.map((name) => `  - ${name}`),
+		"allowBuilds:",
+		...allowBuilds.map((name) => `  ${name}: true`)
+	].join("\n") + "\n";
+}
+//#endregion
+//#region src/generate/readme.ts
+/**
+* Replaces the template's project heading with the generated package name.
+* Keeping the rest of the template untouched makes README updates independent
+* from the scaffolding logic.
+*/
+function renderReadme(template, appName) {
+	return template.replace(/^# my-app$/m, `# ${appName}`);
+}
+//#endregion
+//#region src/generate/tsconfig.ts
+const TSCONFIG = {
+	extends: "@tsconfig/vite-react/tsconfig.json",
+	compilerOptions: { types: ["vite/client", "vitest/globals"] },
+	include: ["src"]
+};
+/** Renders the generated `tsconfig.json` as a string. */
+function buildTsconfig() {
+	return JSON.stringify(TSCONFIG, null, 2) + "\n";
+}
+//#endregion
+//#region src/generate/vite-config.ts
+/**
+* Renders `vite.config.ts` from the folded contribution's Vite imports and
+* plugin list. Generated (not a static template) so a future topping can add
+* plugins without a substitution engine — the baseline output is the invariant
+* `createViteConfig({ plugins: [react()] })`.
+*/
+function renderViteConfig(contribution) {
+	return `${["import { createViteConfig } from '@chanom/vite-config';", ...contribution.viteImports].join("\n")}\n\nexport default createViteConfig({ plugins: [${contribution.vitePlugins.join(", ")}] });\n`;
+}
+//#endregion
+//#region src/templates.ts
+/**
+* Template files copied into every generated app. Source files use
+* a `.template` suffix so repository tooling does not lint, format, or type-check
+* them. `_gitignore` also uses a placeholder name because npm strips a real
+* `.gitignore` from published packages. Files whose content is computed
+* (package.json, vite.config.ts, tsconfig.json, index.html) are generated, not
+* listed here. README.md, app.tsx, and app.test.tsx have their app-name
+* placeholders replaced while copying.
+*/
+const TEMPLATE_FILES = [
+	{
+		src: "_gitignore.template",
+		dest: ".gitignore"
+	},
+	{
+		src: "README.md.template",
+		dest: "README.md"
+	},
+	{
+		src: "oxlint.config.ts.template",
+		dest: "oxlint.config.ts"
+	},
+	{
+		src: "oxfmt.config.ts.template",
+		dest: "oxfmt.config.ts"
+	},
+	{
+		src: "vitest.config.ts.template",
+		dest: "vitest.config.ts"
+	},
+	{
+		src: "src/main.tsx.template",
+		dest: "src/main.tsx"
+	},
+	{
+		src: "src/app.tsx.template",
+		dest: "src/app.tsx"
+	},
+	{
+		src: "src/app.test.tsx.template",
+		dest: "src/app.test.tsx"
+	},
+	{
+		src: "src/index.css.template",
+		dest: "src/index.css"
+	},
+	{
+		src: "src/test-setup.ts.template",
+		dest: "src/test-setup.ts"
+	},
+	{
+		src: "src/vite-env.d.ts.template",
+		dest: "src/vite-env.d.ts"
+	}
+];
+//#endregion
+//#region src/toppings.ts
+/**
+* The always-present baseline: a minimal Vite + React + TS app wired to the
+* chanom shared configs. Its static source files ship as verbatim templates;
+* this contribution supplies only what the generator computes (deps, scripts,
+* the Vite plugin list).
+*/
+const baseline = {
+	dependencies: ["react", "react-dom"],
+	devDependencies: [
+		"@chanom/dev-config",
+		"@chanom/vite-config",
+		"@vitejs/plugin-react",
+		"@tsconfig/vite-react",
+		"@types/react",
+		"@types/react-dom",
+		"typescript",
+		"vite",
+		"vitest",
+		"@vitest/coverage-v8",
+		"jsdom",
+		"@testing-library/react",
+		"@testing-library/jest-dom",
+		"oxlint",
+		"oxlint-tsgolint",
+		"oxfmt"
+	],
+	scripts: {
+		dev: "vite",
+		build: "tsc -b && vite build",
+		preview: "vite preview",
+		lint: "oxlint",
+		format: "oxfmt",
+		"format:check": "oxfmt --check",
+		test: "vitest run",
+		"test:watch": "vitest"
+	},
+	viteImports: ["import react from '@vitejs/plugin-react';"],
+	vitePlugins: ["react()"],
+	files: []
+};
+const LINT_STAGED_CONFIG = {
+	"**/*.{js,jsx,ts,tsx,mjs,cjs,mts,cts}": ["oxlint --fix --no-error-on-unmatched-pattern"],
+	"*": ["oxfmt --no-error-on-unmatched-pattern"]
+};
+const COMMITLINT_CONFIG = { extends: ["@commitlint/config-conventional"] };
+/**
+* The `commit-hooks` topping: husky + lint-staged + commitlint as one unit.
+* Config choices are copied verbatim from `chanom brew`'s add-* commands. No
+* `husky init` runs at generation time (deps are not installed yet); husky's
+* `.husky/_/` materializes on the user's first install via `prepare: "husky"`.
+*/
+function commitHooks(pm) {
+	return {
+		dependencies: [],
+		devDependencies: [
+			"husky",
+			"lint-staged",
+			"@commitlint/cli",
+			"@commitlint/config-conventional"
+		],
+		scripts: { prepare: "husky" },
+		viteImports: [],
+		vitePlugins: [],
+		files: [
+			{
+				path: ".husky/pre-commit",
+				contents: "lint-staged\n"
+			},
+			{
+				path: ".husky/commit-msg",
+				contents: [
+					...PM_EXEC[pm],
+					"commitlint",
+					"--edit",
+					"$1"
+				].join(" ") + "\n"
+			},
+			{
+				path: ".lintstagedrc.json",
+				contents: JSON.stringify(LINT_STAGED_CONFIG, null, 2) + "\n"
+			},
+			{
+				path: ".commitlintrc.json",
+				contents: JSON.stringify(COMMITLINT_CONFIG, null, 2) + "\n"
+			}
+		]
+	};
+}
+/** The baseline plus whichever toppings the resolved options select, in fold order. */
+function selectContributions(selection) {
+	return selection.commitHooks ? [baseline, commitHooks(selection.pm)] : [baseline];
+}
+//#endregion
+//#region src/scaffold.ts
+var InstallFailed = class extends Data.TaggedError("InstallFailed") {};
+const writeFile = Effect.fn("scaffold.writeFile")(function* (targetDir, relPath, contents) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const dest = path.join(targetDir, relPath);
+	yield* fs.makeDirectory(path.dirname(dest), { recursive: true });
+	yield* fs.writeFileString(dest, contents);
+});
+const copyTemplates = Effect.fn("scaffold.copyTemplates")(function* (plan) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const appName = toKebabCase(plan.appName);
+	for (const file of TEMPLATE_FILES) {
+		const template = yield* fs.readFileString(path.join(plan.templatesRoot, file.src));
+		const contents = file.dest === "README.md" ? renderReadme(template, appName) : file.dest === "src/app.tsx" || file.dest === "src/app.test.tsx" ? renderAppTemplate(template, appName) : template;
+		yield* writeFile(plan.targetDir, file.dest, contents);
+	}
+});
+const writeGeneratedFiles = Effect.fn("scaffold.writeGeneratedFiles")(function* (plan, folded) {
+	const appName = toKebabCase(plan.appName);
+	yield* writeFile(plan.targetDir, "package.json", buildPackageJson({
+		appName,
+		packageManager: plan.packageManagerField,
+		contribution: folded,
+		versions: depVersions
+	}));
+	yield* writeFile(plan.targetDir, "pnpm-workspace.yaml", buildPnpmWorkspace());
+	yield* writeFile(plan.targetDir, "vite.config.ts", renderViteConfig(folded));
+	yield* writeFile(plan.targetDir, "tsconfig.json", buildTsconfig());
+	yield* writeFile(plan.targetDir, "index.html", renderIndexHtml(appName));
+	for (const file of folded.files) yield* writeFile(plan.targetDir, file.path, file.contents);
+});
+const initGit = Effect.fn("scaffold.initGit")(function* (plan) {
+	const git = yield* Git;
+	const s = yield* (yield* Prompter).spinner("Initializing git repository...");
+	yield* git.init(plan.targetDir);
+	if (!(yield* git.hasIdentity(plan.targetDir))) yield* git.setLocalIdentity(plan.targetDir, "create-chanom-app", "create-chanom-app@users.noreply.github.com");
+	yield* git.stageAll(plan.targetDir);
+	const result = yield* git.commit(plan.targetDir, "chore: scaffold with create-chanom-app");
+	yield* s.stop(result.ok ? "Git repository initialized" : pc.yellow("Could not create the initial commit"));
+});
+const installDependencies = Effect.fn("scaffold.installDependencies")(function* (plan) {
+	const prompter = yield* Prompter;
+	const runner = yield* CommandRunner;
+	const s = yield* prompter.spinner(`Installing dependencies with ${plan.pm}...`);
+	if ((yield* runner.execInherit(plan.pm, ["install"], plan.targetDir).pipe(Effect.tapError(() => s.stop(pc.red("Dependency installation failed"))))) !== 0) {
+		yield* s.stop(pc.red("Dependency installation failed"));
+		return yield* new InstallFailed({ pm: plan.pm });
+	}
+	yield* s.stop("Dependencies installed");
+});
+/** Writes the generated app, then optionally initializes git and installs deps. */
+const scaffold = Effect.fn("scaffold")(function* (plan) {
+	const fs = yield* FileSystem.FileSystem;
+	const folded = mergeContributions(selectContributions({
+		pm: plan.pm,
+		commitHooks: plan.commitHooks
+	}));
+	yield* fs.makeDirectory(plan.targetDir, { recursive: true });
+	yield* copyTemplates(plan);
+	yield* writeGeneratedFiles(plan, folded);
+	if (plan.git) yield* initGit(plan);
+	if (plan.install) yield* installDependencies(plan);
+});
+//#endregion
+//#region src/cli.ts
+const DEFAULT_NAME = "my-chanom-app";
+const HELP = `${pc.bold("create-chanom-app")} ${pc.dim("- scaffold a Vite + React + TS app")}
+
+${pc.bold("Usage")}
+  npm create chanom-app@latest ${pc.dim("[directory] [options]")}
+  pnpm create chanom-app ${pc.dim("[directory] [options]")}
+
+${pc.bold("Options")}
+  ${pc.cyan("[directory]")}                 Target directory / project name (prompted if omitted)
+  ${pc.cyan("--git / --no-git")}            Initialize a git repository (default: yes)
+  ${pc.cyan("--commit-hooks")}              Add husky + lint-staged + commitlint (requires git)
+  ${pc.cyan("--no-commit-hooks")}           Skip the commit-hooks topping
+  ${pc.cyan("--install / --no-install")}    Install dependencies after scaffolding (default: install)
+  ${pc.cyan("--pm <pnpm|npm|yarn|bun>")}    Package manager to record (default: detected)
+  ${pc.cyan("-y, --yes")}                   Accept all defaults, no prompts (CI-friendly)
+  ${pc.cyan("--help")}                      Show this help
+  ${pc.cyan("--version")}                   Show the version`;
+var TargetNotEmpty = class extends Data.TaggedError("TargetNotEmpty") {};
+/**
+* `pnpm@11.9.0`-style field from the create launcher's user agent. Only the
+* leading token is the real launcher (`npm/?` placeholders trail it), so the
+* field is written only when it matches the resolved PM and carries a version.
+*/
+function packageManagerField(pm, userAgent) {
+	const [name, version] = (userAgent?.split(" ")[0] ?? "").split("/");
+	return name === pm && version && version !== "?" ? `${pm}@${version}` : void 0;
+}
+/** flag wins, then `--yes`/default, otherwise ask. Building the ask effect is side-effect-free. */
+function resolveConfirm(flag, yes, ask) {
+	if (flag !== void 0) return Effect.succeed(flag);
+	return yes ? Effect.succeed(true) : ask;
+}
+const isEmptyDir = Effect.fn("cli.isEmptyDir")(function* (dir) {
+	const fs = yield* FileSystem.FileSystem;
+	if (!(yield* fs.exists(dir))) return true;
+	return (yield* fs.readDirectory(dir)).filter((entry) => entry !== ".git").length === 0;
+});
+const program$1 = (argv, cwd, options) => Effect.gen(function* () {
+	const prompter = yield* Prompter;
+	const path = yield* Path.Path;
+	const parsed = parseArgs(argv);
+	if (!parsed.ok) {
+		yield* prompter.error(parsed.message);
+		return 1;
+	}
+	const args = parsed.args;
+	if (args.help) {
+		yield* prompter.message(HELP);
+		return 0;
+	}
+	if (args.version) {
+		yield* prompter.message(pkgVersion);
+		return 0;
+	}
+	if (args.directory !== void 0) {
+		const invalid = validateProjectName(args.directory);
+		if (invalid !== void 0) {
+			yield* prompter.error(invalid);
+			return 1;
+		}
+	}
+	yield* prompter.intro(pc.magenta("🧋 create-chanom-app"));
+	let directory;
+	if (args.directory !== void 0) directory = toKebabCase(args.directory);
+	else if (args.yes) directory = DEFAULT_NAME;
+	else directory = yield* prompter.text({
+		message: "Project name?",
+		placeholder: DEFAULT_NAME,
+		defaultValue: DEFAULT_NAME,
+		validate: validateProjectName
+	});
+	if (directory === void 0) return 1;
+	const targetDir = path.resolve(cwd, directory);
+	const appName = path.basename(targetDir);
+	if (!(yield* isEmptyDir(targetDir))) return yield* new TargetNotEmpty({ directory });
+	const git = yield* resolveConfirm(args.git, args.yes, prompter.confirm({
+		message: "Initialize a git repository?",
+		initialValue: true
+	}));
+	const commitHooks = git ? yield* resolveConfirm(args.commitHooks, args.yes, prompter.confirm({
+		message: "Add commit hooks (husky + lint-staged + commitlint)?",
+		initialValue: true
+	})) : false;
+	const install = yield* resolveConfirm(args.install, args.yes, prompter.confirm({
+		message: "Install dependencies now?",
+		initialValue: true
+	}));
+	const pm = args.pm ?? resolvePm({
+		userAgent: options.userAgent,
+		fallback: "pnpm"
+	});
+	yield* prompter.message([
+		`${pc.dim("directory")}     ${directory}`,
+		`${pc.dim("package mgr")}   ${pm}`,
+		`${pc.dim("git")}           ${git ? "yes" : "no"}`,
+		`${pc.dim("commit hooks")}  ${git ? commitHooks ? "yes" : "no" : pc.dim("n/a")}`,
+		`${pc.dim("install")}       ${install ? "yes" : "no"}`
+	].join("\n"));
+	yield* scaffold({
+		targetDir,
+		appName,
+		pm,
+		packageManagerField: packageManagerField(pm, options.userAgent),
+		git,
+		commitHooks,
+		install,
+		templatesRoot: options.templatesRoot
+	});
+	const steps = [
+		...directory === "." ? [] : [`cd ${directory}`],
+		...install ? [] : [`${pm} install`],
+		`${pm} run dev`
+	];
+	yield* prompter.outro(pc.green(`Done! Next steps:\n  ${steps.join("\n  ")}`));
+	return 0;
+});
+const reportError = (message) => Effect.gen(function* () {
+	yield* (yield* Prompter).error(message);
+	return 1;
+});
+/** Runs the scaffolder and returns the process exit code. */
+const run = (argv, cwd, options) => {
+	const debug = options.debug ?? false;
+	return program$1(argv, cwd, options).pipe(Effect.catchTags({
+		Cancelled: () => Effect.succeed(0),
+		TargetNotEmpty: (e) => reportError(`${e.directory} is not empty. Aborting.`),
+		InstallFailed: (e) => reportError(`Dependency installation with ${e.pm} failed.`)
+	}), Effect.catchAll((e) => reportError(`Unexpected error: ${e.message}`)), Logger.withMinimumLogLevel(debug ? LogLevel.Debug : LogLevel.Info));
+};
+//#endregion
+//#region src/index.ts
+const debug = process.argv.includes("--debug");
+const argv = process.argv.slice(2).filter((arg) => arg !== "--debug");
+const templatesRoot = join(import.meta.dirname, "templates");
+const ServicesLive = Layer.mergeAll(Prompter.Default, Git.Default).pipe(Layer.provideMerge(CommandRunner.Default), Layer.provideMerge(NodeContext.layer));
+const DebugLoggerLive = Logger.replace(Logger.defaultLogger, Logger.prettyLogger({ stderr: true }));
+const MainLive = debug ? Layer.merge(ServicesLive, DebugLoggerLive) : ServicesLive;
+const program = run(argv, process.cwd(), {
+	userAgent: process.env["npm_config_user_agent"],
+	templatesRoot,
+	debug
+}).pipe(Effect.flatMap((exitCode) => Effect.sync(() => {
+	if (exitCode !== 0) process.exitCode = exitCode;
+})), Effect.provide(MainLive));
+NodeRuntime.runMain(program, {
+	disableErrorReporting: true,
+	disablePrettyLogger: true
+});
+//#endregion
+export {};

package/dist/templates/README.md.template

@@ -0,0 +1,16 @@
+# my-app
+
+Brewed with [create-chanom-app](https://github.com/peeranat-dan/chanom).
+
+## Scripts
+
+| Command             | What it does                          |
+| ------------------- | ------------------------------------- |
+| `pnpm dev`          | Start the Vite dev server             |
+| `pnpm build`        | Type-check, then build for production |
+| `pnpm preview`      | Preview the production build          |
+| `pnpm lint`         | Lint with oxlint                      |
+| `pnpm format`       | Format with oxfmt                     |
+| `pnpm format:check` | Check formatting without writing      |
+| `pnpm test`         | Run the test suite once               |
+| `pnpm test:watch`   | Run tests in watch mode               |

package/dist/templates/_gitignore.template

@@ -0,0 +1,5 @@
+node_modules
+dist
+coverage
+*.local
+.DS_Store

package/dist/templates/oxfmt.config.ts.template

@@ -0,0 +1 @@
+export { default } from '@chanom/dev-config/oxfmt/config';

package/dist/templates/oxlint.config.ts.template

@@ -0,0 +1 @@
+export { default } from '@chanom/dev-config/oxlint/config';

package/dist/templates/src/app.test.tsx.template

@@ -0,0 +1,8 @@
+import { render, screen } from '@testing-library/react';
+
+import { App } from './app';
+
+test('renders the app heading', () => {
+  render(<App />);
+  expect(screen.getByRole('heading', { name: 'my-app' })).toBeInTheDocument();
+});

package/dist/templates/src/app.tsx.template

@@ -0,0 +1,8 @@
+export function App() {
+  return (
+    <main>
+      <h1>my-app</h1>
+      <p>Brewed with create-chanom-app.</p>
+    </main>
+  );
+}

package/dist/templates/src/index.css.template

@@ -0,0 +1,11 @@
+:root {
+  font-family: system-ui, sans-serif;
+  line-height: 1.5;
+}
+
+body {
+  margin: 0;
+  display: grid;
+  place-items: center;
+  min-height: 100vh;
+}

package/dist/templates/src/main.tsx.template

@@ -0,0 +1,14 @@
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+
+import { App } from './app';
+import './index.css';
+
+const rootElement = document.getElementById('root');
+if (!rootElement) throw new Error('Root element #root not found');
+
+createRoot(rootElement).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+);

package/dist/templates/src/test-setup.ts.template

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/vitest';

package/dist/templates/src/vite-env.d.ts.template

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/dist/templates/vitest.config.ts.template

@@ -0,0 +1,8 @@
+import { createReactAppVitestConfig } from '@chanom/vite-config/vitest';
+import react from '@vitejs/plugin-react';
+
+export default createReactAppVitestConfig({
+  plugins: [react()],
+  setupFiles: ['./src/test-setup.ts'],
+  coverage: true,
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "create-chanom-app",
+  "version": "0.0.0",
+  "description": "Scaffold a Vite + React + TypeScript app, wired to the chanom shared configs.",
+  "keywords": [
+    "create",
+    "react",
+    "scaffold",
+    "starter",
+    "typescript",
+    "vite"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/peeranat-dan/chanom.git",
+    "directory": "packages/create-chanom-app"
+  },
+  "bin": {
+    "create-chanom-app": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "1.6.0",
+    "@effect/platform": "0.96.2",
+    "@effect/platform-node": "0.107.0",
+    "effect": "3.21.4",
+    "picocolors": "1.1.1"
+  },
+  "devDependencies": {
+    "@effect/language-service": "0.86.4",
+    "@effect/vitest": "0.29.0",
+    "@tsconfig/node-lts": "24.0.0",
+    "@tsconfig/node-ts": "23.6.4",
+    "@types/node": "26.0.1",
+    "@vitest/coverage-v8": "3.2.6",
+    "tsdown": "0.22.3",
+    "typescript": "6.0.3",
+    "vitest": "3.2.6",
+    "@chanom/dev-config": "0.0.3",
+    "@chanom/internal": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest"
+  }
+}