create-chanom-app 0.4.3 → 0.5.0

package/README.md

@@ -29,10 +29,11 @@ pnpm create chanom-app .
 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.
+2. **Initialize a git repository?** - `git init` plus an initial commit (made after the install, so it includes the lockfile).
 3. **Add commit hooks?** - husky + lint-staged + commitlint (only asked when git is enabled).
 4. **Add agent coding standards?** - the `coding-standards` skill in `.agents/skills`, linked into `.claude/skills`.
-5. **Install dependencies now?** - runs `<pm> install` after scaffolding.
+5. **Add a GitHub Actions CI workflow?** - `.github/workflows/ci.yml`; if yes, pick its jobs from `lint`, `build`, `typecheck`, `test` (all checked by default).
+6. **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`).
 
@@ -46,13 +47,16 @@ Every prompt has a matching flag so you can pre-answer any of them (or all, with
 | `--no-commit-hooks`           | Skip the commit-hooks topping                             |
 | `--agent-skills`              | Add the coding-standards skill (default: yes)             |
 | `--no-agent-skills`           | Skip the agent-skills topping                             |
+| `--github-actions`            | Add a GitHub Actions CI workflow (default: yes)           |
+| `--no-github-actions`         | Skip the github-actions topping                           |
+| `--ci-jobs <jobs>`            | Comma-separated CI jobs, e.g. `lint,test` (default: all)  |
 | `--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.
+`--no-git --commit-hooks` is rejected: husky needs a repo to install into. `--no-github-actions --ci-jobs` is rejected too. `--ci-jobs` on its own turns the topping on.
 
 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.
 
@@ -81,6 +85,8 @@ With the **commit-hooks** topping, it also adds husky, lint-staged, and commitli
 
 With the **agent-skills** topping, it adds the `coding-standards` agent skill - a router `SKILL.md` plus TypeScript, React, and Vitest references written for exactly the stack scaffolded here. The real files land in `.agents/skills/coding-standards/` so any agent tool can read them, and `.claude/skills/coding-standards` is a relative symlink pointing at that directory rather than a second copy. It contributes no packages and no scripts, so skipping it leaves both directories out entirely.
 
+With the **github-actions** topping, it adds `.github/workflows/ci.yml` - the same workflow `chanom brew` writes. It runs on every pull request with one independent job per check you picked. Each job sets up your package manager and the latest LTS Node, runs `<pm> install` with a frozen lockfile, then `<pm> run <job>`. The generated app ships all four scripts, so every job works as generated. When dependencies are installed during scaffolding, the lockfile lands in the initial commit; with `--no-install`, commit it after your first install - the frozen install fails without it.
+
 ## Development
 
 ```sh

package/dist/index.js

@@ -1,10 +1,134 @@
 #!/usr/bin/env node
+import { Document, isMap, isNode, isScalar, isSeq, stringify } from "yaml";
 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";
+// ../internal/src/domain/yaml.ts
+/** Stringify options shared by every YAML file chanom generates, so they all read alike. */
+const YAML_OPTIONS = {
+	singleQuote: true,
+	lineWidth: 0,
+	flowCollectionPadding: false
+};
+/**
+* Puts a blank line before every entry of a map or sequence node except the
+* first. Mutates the node, so only call it on a `Document` built for output.
+*/
+function spaceItems(node) {
+	if (isMap(node)) {
+		for (const pair of node.items.slice(1)) if (isScalar(pair.key)) pair.key.spaceBefore = true;
+	} else if (isSeq(node)) {
+		for (const item of node.items.slice(1)) if (isNode(item)) item.spaceBefore = true;
+	}
+}
+// ../internal/src/domain/github-actions.ts
+/** Every job the workflow can contain, in the order they appear in the file. */
+const CI_JOBS = [
+	"lint",
+	"build",
+	"typecheck",
+	"test"
+];
+const WORKFLOW_PATH = ".github/workflows/ci.yml";
+const INSTALL_COMMAND = {
+	pnpm: "pnpm install --frozen-lockfile",
+	npm: "npm ci",
+	yarn: "yarn install --frozen-lockfile",
+	bun: "bun install --frozen-lockfile"
+};
+const JOB_STEP_NAME = {
+	lint: "Lint",
+	build: "Build",
+	typecheck: "Typecheck",
+	test: "Test"
+};
+function setupNode(cache, hasNvmrc) {
+	return {
+		uses: "actions/setup-node@v6",
+		with: {
+			...hasNvmrc ? { "node-version-file": ".nvmrc" } : { "node-version": "lts/*" },
+			cache
+		}
+	};
+}
+/** Steps that bring a job up to "dependencies installed". */
+function setupSteps(options) {
+	const checkout = { uses: "actions/checkout@v7" };
+	const install = {
+		name: "Install dependencies",
+		run: INSTALL_COMMAND[options.pm]
+	};
+	switch (options.pm) {
+		case "pnpm": return [
+			checkout,
+			options.hasPackageManagerField ? { uses: "pnpm/action-setup@v6" } : {
+				uses: "pnpm/action-setup@v6",
+				with: { version: "latest" }
+			},
+			setupNode("pnpm", options.hasNvmrc),
+			install
+		];
+		case "npm": return [
+			checkout,
+			setupNode("npm", options.hasNvmrc),
+			install
+		];
+		case "yarn": return [
+			checkout,
+			{ run: "corepack enable" },
+			setupNode("yarn", options.hasNvmrc),
+			install
+		];
+		case "bun": return [
+			checkout,
+			{ uses: "oven-sh/setup-bun@v2" },
+			install
+		];
+	}
+}
+/** Selected jobs deduplicated and put in workflow order. */
+function orderJobs(jobs) {
+	return CI_JOBS.filter((job) => jobs.includes(job));
+}
+/**
+* `.github/workflows/ci.yml` contents: one independent job per selected check,
+* each running `<pm> run <job>`. Shared so `chanom brew` and
+* `create-chanom-app` emit byte-identical workflows.
+*/
+function workflowFile(options) {
+	const jobs = Object.fromEntries(orderJobs(options.jobs).map((job) => [job, {
+		"runs-on": "ubuntu-latest",
+		steps: [...setupSteps(options), {
+			name: JOB_STEP_NAME[job],
+			run: `${options.pm} run ${job}`
+		}]
+	}]));
+	const doc = new Document({
+		name: "CI",
+		on: { pull_request: { branches: ["*"] } },
+		concurrency: {
+			group: "${{ github.workflow }}-${{ github.ref }}",
+			"cancel-in-progress": true
+		},
+		jobs
+	});
+	spaceItems(doc.contents);
+	const branches = doc.getIn([
+		"on",
+		"pull_request",
+		"branches"
+	], true);
+	if (isSeq(branches)) branches.flow = true;
+	const jobNodes = doc.get("jobs", true);
+	spaceItems(jobNodes);
+	if (isMap(jobNodes)) {
+		for (const pair of jobNodes.items) if (isMap(pair.value)) spaceItems(pair.value.get("steps", true));
+	}
+	return doc.toString(YAML_OPTIONS);
+}
 // ../internal/src/domain/package-manager.ts
 /** How to run a locally installed binary with each package manager. */
 const PM_EXEC = {
@@ -193,7 +317,8 @@ var Prompter = class extends Effect.Service()("internal/Prompter", { succeed: {
 	multiselect: (params) => guardCancel(() => clack.multiselect({
 		message: params.message,
 		options: [...params.options],
-		required: params.required ?? false
+		required: params.required ?? false,
+		initialValues: params.initialValues && [...params.initialValues]
 	})),
 	spinner: (message) => Effect.sync(() => {
 		const s = clack.spinner();
@@ -278,7 +403,7 @@ const depVersions = {
 	"@chanom/vite-config": "0.1.2"
 };
 /** This package's own version, for `--version`. */
-const pkgVersion = "0.4.3";
+const pkgVersion = "0.5.0";
 // src/domain/args.ts
 const PACKAGE_MANAGERS = [
 	"pnpm",
@@ -287,11 +412,12 @@ const PACKAGE_MANAGERS = [
 	"bun"
 ];
 const isPackageManager = (value) => PACKAGE_MANAGERS.includes(value);
+const isCiJob = (value) => CI_JOBS.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).
+* contradictory `--no-git --commit-hooks` and `--no-github-actions --ci-jobs`
+* pairs are rejected here rather than silently reconciled.
 */
 function parseArgs(argv) {
 	const args = {
@@ -331,6 +457,27 @@ function parseArgs(argv) {
 			case "--no-agent-skills":
 				args.agentSkills = false;
 				break;
+			case "--github-actions":
+				args.githubActions = true;
+				break;
+			case "--no-github-actions":
+				args.githubActions = false;
+				break;
+			case "--ci-jobs": {
+				const value = argv[++i];
+				if (value === void 0) return {
+					ok: false,
+					message: "--ci-jobs requires a value."
+				};
+				const jobs = value.split(",").map((job) => job.trim());
+				const unknown = jobs.find((job) => !isCiJob(job));
+				if (unknown !== void 0) return {
+					ok: false,
+					message: `Unknown CI job "${unknown}". Use any of: ${CI_JOBS.join(", ")}.`
+				};
+				args.ciJobs = jobs.filter(isCiJob);
+				break;
+			}
 			case "--install":
 				args.install = true;
 				break;
@@ -366,6 +513,10 @@ function parseArgs(argv) {
 		ok: false,
 		message: "--commit-hooks requires a git repo. Remove --no-git or --commit-hooks."
 	};
+	if (args.githubActions === false && args.ciJobs !== void 0) return {
+		ok: false,
+		message: "--ci-jobs needs the github-actions topping. Remove --no-github-actions or --ci-jobs."
+	};
 	return {
 		ok: true,
 		args
@@ -511,12 +662,10 @@ 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";
+	return stringify({
+		onlyBuiltDependencies,
+		allowBuilds: Object.fromEntries(allowBuilds.map((name) => [name, true]))
+	}, YAML_OPTIONS);
 }
 // src/generate/readme.ts
 /**
@@ -713,11 +862,32 @@ const agentSkills = {
 	files: skillFiles(codingStandardsSkill),
 	links: [skillLink(codingStandardsSkill)]
 };
+/**
+* The `github-actions` topping: a CI workflow with one job per chosen check,
+* identical to what `chanom brew` writes. The baseline ships every script the
+* jobs run, so each job works out of the box. The generated app has no
+* `.nvmrc`, so setup-node uses the latest LTS.
+*/
+function githubActions(pm, jobs, hasPackageManagerField) {
+	return {
+		...emptyContribution,
+		files: [{
+			path: WORKFLOW_PATH,
+			contents: workflowFile({
+				pm,
+				jobs,
+				hasNvmrc: false,
+				hasPackageManagerField
+			})
+		}]
+	};
+}
 /** The baseline plus whichever toppings the resolved options select, in fold order. */
 function selectContributions(selection) {
 	const contributions = [baseline];
 	if (selection.commitHooks) contributions.push(commitHooks(selection.pm));
 	if (selection.agentSkills) contributions.push(agentSkills);
+	if (selection.ciJobs.length > 0) contributions.push(githubActions(selection.pm, selection.ciJobs, selection.hasPackageManagerField));
 	return contributions;
 }
 // src/scaffold.ts
@@ -777,10 +947,15 @@ 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);
+	yield* s.stop("Git repository initialized");
+});
+const commitScaffold = Effect.fn("scaffold.commitScaffold")(function* (plan) {
+	const git = yield* Git;
+	const s = yield* (yield* Prompter).spinner("Creating the initial commit...");
 	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"));
+	yield* s.stop(result.ok ? "Initial commit created" : pc.yellow("Could not create the initial commit"));
 });
 const installDependencies = Effect.fn("scaffold.installDependencies")(function* (plan) {
 	const prompter = yield* Prompter;
@@ -796,19 +971,22 @@ const installDependencies = Effect.fn("scaffold.installDependencies")(function*
 	}
 	yield* s.stop("Dependencies installed");
 });
-/** Writes the generated app, then optionally initializes git and installs deps. */
+/** Writes the generated app, then optionally initializes git, installs deps, and commits. */
 const scaffold = Effect.fn("scaffold")(function* (plan) {
 	const fs = yield* FileSystem.FileSystem;
 	const folded = mergeContributions(selectContributions({
 		pm: plan.pm,
 		commitHooks: plan.commitHooks,
-		agentSkills: plan.agentSkills
+		agentSkills: plan.agentSkills,
+		ciJobs: plan.ciJobs,
+		hasPackageManagerField: plan.packageManagerField !== void 0
 	}));
 	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);
+	if (plan.install) yield* installDependencies(plan).pipe(Effect.tapError(() => plan.git ? commitScaffold(plan) : Effect.void));
+	if (plan.git) yield* commitScaffold(plan);
 });
 // src/cli.ts
 const DEFAULT_NAME = "my-chanom-app";
@@ -825,6 +1003,9 @@ ${pc.bold("Options")}
   ${pc.cyan("--no-commit-hooks")}           Skip the commit-hooks topping
   ${pc.cyan("--agent-skills")}              Add the coding-standards skill to .claude/skills
   ${pc.cyan("--no-agent-skills")}           Skip the agent-skills topping
+  ${pc.cyan("--github-actions")}            Add a GitHub Actions CI workflow
+  ${pc.cyan("--no-github-actions")}         Skip the github-actions topping
+  ${pc.cyan("--ci-jobs <jobs>")}            Comma-separated CI jobs: ${CI_JOBS.join(", ")} (default: all)
   ${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)
@@ -845,6 +1026,28 @@ function resolveConfirm(flag, yes, ask) {
 	if (flag !== void 0) return Effect.succeed(flag);
 	return yes ? Effect.succeed(true) : ask;
 }
+/**
+* `--ci-jobs` implies the topping and wins over the jobs prompt; `--yes` takes
+* every job. Returns no jobs when the topping is declined.
+*/
+const resolveCiJobs = Effect.fn("cli.resolveCiJobs")(function* (flag, jobs, yes) {
+	const prompter = yield* Prompter;
+	if (!(yield* resolveConfirm(jobs === void 0 ? flag : true, yes, prompter.confirm({
+		message: "Add a GitHub Actions CI workflow?",
+		initialValue: true
+	})))) return [];
+	if (jobs !== void 0) return jobs;
+	if (yes) return CI_JOBS;
+	return yield* prompter.multiselect({
+		message: "Which GitHub Actions jobs would you like?",
+		options: CI_JOBS.map((job) => ({
+			value: job,
+			label: job
+		})),
+		initialValues: CI_JOBS,
+		required: true
+	});
+});
 const isEmptyDir = Effect.fn("cli.isEmptyDir")(function* (dir) {
 	const fs = yield* FileSystem.FileSystem;
 	if (!(yield* fs.exists(dir))) return true;
@@ -900,6 +1103,7 @@ const program$1 = (argv, cwd, options) => Effect.gen(function* () {
 		message: "Add agent coding standards (.agents/skills)?",
 		initialValue: true
 	}));
+	const ciJobs = yield* resolveCiJobs(args.githubActions, args.ciJobs, args.yes);
 	const install = yield* resolveConfirm(args.install, args.yes, prompter.confirm({
 		message: "Install dependencies now?",
 		initialValue: true
@@ -914,6 +1118,7 @@ const program$1 = (argv, cwd, options) => Effect.gen(function* () {
 		`${pc.dim("git")}           ${git ? "yes" : "no"}`,
 		`${pc.dim("commit hooks")}  ${git ? commitHooks ? "yes" : "no" : pc.dim("n/a")}`,
 		`${pc.dim("agent skills")}  ${agentSkills ? "yes" : "no"}`,
+		`${pc.dim("ci jobs")}       ${ciJobs.length > 0 ? ciJobs.join(", ") : "no"}`,
 		`${pc.dim("install")}       ${install ? "yes" : "no"}`
 	].join("\n"));
 	yield* scaffold({
@@ -924,6 +1129,7 @@ const program$1 = (argv, cwd, options) => Effect.gen(function* () {
 		git,
 		commitHooks,
 		agentSkills,
+		ciJobs,
 		install,
 		templatesRoot: options.templatesRoot
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-chanom-app",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "Scaffold a Vite + React + TypeScript app, wired to the chanom shared configs.",
   "keywords": [
     "create",
@@ -30,7 +30,8 @@
     "@effect/platform": "0.96.2",
     "@effect/platform-node": "0.107.0",
     "effect": "3.22.4",
-    "picocolors": "1.1.1"
+    "picocolors": "1.1.1",
+    "yaml": "2.9.0"
   },
   "devDependencies": {
     "@effect/language-service": "0.86.4",