@chanom/cli 0.4.4 → 0.5.0

package/README.md

@@ -1,6 +1,6 @@
 # @chanom/cli
 
-Interactive CLI that brews dev tooling config into your project - oxlint, oxfmt, knip, VS Code settings, agent coding standards, and commit hooks, picked with a couple of prompts.
+Interactive CLI that brews dev tooling config into your project - oxlint, oxfmt, knip, VS Code settings, agent coding standards, a GitHub Actions CI workflow, and commit hooks, picked with a couple of prompts.
 
 ## Install
 
@@ -32,7 +32,7 @@ chanom brew --debug
 
 Debug mode logs each step (detected package manager, planned packages, every command it spawns and its exit code) to stderr, and on failure prints the full error trace including which step failed.
 
-`brew` walks you through two prompts:
+`brew` walks you through two prompts (plus a third when you pick `github-actions`):
 
 1. **Toppings** - which tools to add, any combination (or none):
    - `oxlint` - fast Rust-based linter
@@ -40,6 +40,7 @@ Debug mode logs each step (detected package manager, planned packages, every com
    - `knip` - dead code remover
    - `vscode` - editor settings + extension recommendations
    - `skills` - coding standards for AI agents (`.claude/skills`)
+   - `github-actions` - CI workflow (`.github/workflows/ci.yml`), then pick its jobs: any of `lint`, `build`, `typecheck`, `test`
 2. **Sweetness** - how strict to be:
    - `light` - warn only, no blocking
    - `medium` - block on commit via husky + lint-staged + commitlint
@@ -62,13 +63,14 @@ installing anything. `light` sweetness works anywhere in the repo.
 
 ## What gets added
 
-| Topping  | Config file                                                                     | Scripts added            |
-| -------- | ------------------------------------------------------------------------------- | ------------------------ |
-| `oxlint` | `oxlint.config.ts`\*                                                            | `lint`, `lint:fix`       |
-| `oxfmt`  | `oxfmt.config.ts`\*                                                             | `format`, `format:check` |
-| `knip`   | `knip.config.ts`\*                                                              | `knip`                   |
-| `vscode` | `.vscode/settings.json`, `.vscode/extensions.json`                              | none                     |
-| `skills` | `.agents/skills/coding-standards/`, `.claude/skills/coding-standards` (symlink) | none                     |
+| Topping          | Config file                                                                     | Scripts added            |
+| ---------------- | ------------------------------------------------------------------------------- | ------------------------ |
+| `oxlint`         | `oxlint.config.ts`\*                                                            | `lint`, `lint:fix`       |
+| `oxfmt`          | `oxfmt.config.ts`\*                                                             | `format`, `format:check` |
+| `knip`           | `knip.config.ts`\*                                                              | `knip`                   |
+| `vscode`         | `.vscode/settings.json`, `.vscode/extensions.json`                              | none                     |
+| `skills`         | `.agents/skills/coding-standards/`, `.claude/skills/coding-standards` (symlink) | none                     |
+| `github-actions` | `.github/workflows/ci.yml`                                                      | none                     |
 
 \* `.mts` instead of `.ts` when your project is CommonJS (no `"type": "module"` in `package.json`).
 
@@ -95,6 +97,15 @@ tool can read it, and links `.claude/skills/coding-standards` at that directory
 with a relative symlink rather than keeping a second copy. The standards target
 the stack chanom scaffolds (Vite + React + TypeScript, oxlint, oxfmt, vitest).
 
+The `github-actions` topping installs no packages and adds no scripts. It
+writes a CI workflow that runs on every pull request, with one independent job
+per check you picked. Each job checks out the repo, sets up your package
+manager and Node (from `.nvmrc` when present, otherwise the latest LTS),
+installs dependencies from the lockfile, and runs `<pm> run <job>`. The job
+calls the matching `package.json` script, so `brew` warns about each selected
+job that has no script yet (the `lint` script from the `oxlint` topping
+counts).
+
 `medium` sweetness additionally adds:
 
 - `husky` - installed via `husky init`
@@ -120,6 +131,7 @@ Existing setup is never overwritten:
   setting you already have wins (and is warned about), and existing extension
   recommendations are kept. A `.vscode` file that can't be parsed as JSON (e.g. it
   has comments) is left untouched with a warning.
+- An existing `.github/workflows/ci.yml` is left untouched with a warning.
 - Skill files already on disk are warned about and skipped, and an existing
   `.claude/skills/coding-standards` (a link of your own, or a real directory you
   maintain by hand) is left alone - so re-running never overwrites standards you

package/dist/index.js

@@ -1,9 +1,133 @@
 #!/usr/bin/env node
+import { Document, isMap, isNode, isScalar, isSeq } from "yaml";
 import { Command, CommandExecutor, FileSystem, Path } from "@effect/platform";
 import { Cause, Chunk, 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";
+// ../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 = {
@@ -227,7 +351,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();
@@ -471,7 +596,7 @@ function commitMsgHook(pm) {
 	].join(" ") + "\n";
 }
 // src/commands/add-commitlint/index.ts
-const apply$7 = Effect.fn("add-commitlint.apply")(function* (cwd, pm) {
+const apply$8 = Effect.fn("add-commitlint.apply")(function* (cwd, pm) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -485,6 +610,38 @@ const apply$7 = Effect.fn("add-commitlint.apply")(function* (cwd, pm) {
 		else yield* fs.writeFileString(hookPath, commitMsgHook(pm));
 	}
 });
+// src/commands/add-github-actions/logic.ts
+/** Selected jobs whose `<pm> run <job>` has no matching script in package.json. */
+function missingScripts(scripts, jobs) {
+	return orderJobs(jobs).filter((job) => scripts?.[job] === void 0);
+}
+// src/commands/add-github-actions/index.ts
+/**
+* Writes `.github/workflows/ci.yml` with one job per selected check. An
+* existing workflow is left alone. `pkg` should already carry the scripts the
+* other toppings added, so the missing-script warning only names scripts the
+* user still has to write. Contributes no packages and no scripts, so - like
+* `add-vscode` - it returns nothing for the caller to persist.
+*/
+const apply$7 = Effect.fn("add-github-actions.apply")(function* (cwd, pm, pkg, jobs) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const prompter = yield* Prompter;
+	const filePath = path.join(cwd, WORKFLOW_PATH);
+	if (yield* fs.exists(filePath)) {
+		yield* prompter.warn(`\`${WORKFLOW_PATH}\` already exists - skipping GitHub Actions workflow`);
+		return;
+	}
+	const hasNvmrc = yield* fs.exists(path.join(cwd, ".nvmrc"));
+	yield* fs.makeDirectory(path.dirname(filePath), { recursive: true });
+	yield* fs.writeFileString(filePath, workflowFile({
+		pm,
+		jobs,
+		hasNvmrc,
+		hasPackageManagerField: pkg.packageManager !== void 0
+	}));
+	for (const job of missingScripts(pkg.scripts, jobs)) yield* prompter.warn(`No \`${job}\` script in package.json - the \`${job}\` CI job will fail until you add one`);
+});
 // src/commands/add-husky/logic.ts
 function getPackages$4(pkg) {
 	return isPackageInstalled(pkg, "husky") ? [] : ["husky"];
@@ -897,38 +1054,53 @@ const ensureGitIgnore = Effect.fn("brew.ensureGitIgnore")(function* (cwd) {
 });
 const askRecipe = Effect.fn("brew.askRecipe")(function* () {
 	const prompter = yield* Prompter;
+	const toppings = yield* prompter.multiselect({
+		message: "Which toppings would you like?",
+		options: [
+			{
+				value: "oxlint",
+				label: "oxlint",
+				hint: "fast Rust-based linter"
+			},
+			{
+				value: "oxfmt",
+				label: "oxfmt",
+				hint: "fast Rust-based formatter"
+			},
+			{
+				value: "knip",
+				label: "knip",
+				hint: "dead code remover"
+			},
+			{
+				value: "vscode",
+				label: "vscode",
+				hint: "editor settings + extension recommendations"
+			},
+			{
+				value: "skills",
+				label: "skills",
+				hint: "coding standards for AI agents (.claude/skills)"
+			},
+			{
+				value: "github-actions",
+				label: "github-actions",
+				hint: "CI workflow (.github/workflows)"
+			}
+		],
+		required: false
+	});
 	return {
-		toppings: yield* prompter.multiselect({
-			message: "Which toppings would you like?",
-			options: [
-				{
-					value: "oxlint",
-					label: "oxlint",
-					hint: "fast Rust-based linter"
-				},
-				{
-					value: "oxfmt",
-					label: "oxfmt",
-					hint: "fast Rust-based formatter"
-				},
-				{
-					value: "knip",
-					label: "knip",
-					hint: "dead code remover"
-				},
-				{
-					value: "vscode",
-					label: "vscode",
-					hint: "editor settings + extension recommendations"
-				},
-				{
-					value: "skills",
-					label: "skills",
-					hint: "coding standards for AI agents (.claude/skills)"
-				}
-			],
-			required: false
-		}),
+		toppings,
+		ciJobs: toppings.includes("github-actions") ? 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
+		}) : [],
 		sweetness: yield* prompter.select({
 			message: "How sweet would you like it?",
 			options: [{
@@ -954,13 +1126,14 @@ const installPackages = Effect.fn("brew.installPackages")(function* (pm, cwd, pa
 	yield* installer.installDev(pm, cwd, packages).pipe(Effect.tapError(() => s.stop(pc.red("Package installation failed"))));
 	yield* s.stop("Packages installed");
 });
-const applyToppings = Effect.fn("brew.applyToppings")(function* (cwd, esm, pkg, toppings) {
+const applyToppings = Effect.fn("brew.applyToppings")(function* (cwd, pm, esm, pkg, toppings, ciJobs) {
 	let updated = pkg;
 	if (toppings.includes("oxlint")) updated = yield* apply$2(cwd, esm, updated);
 	if (toppings.includes("oxfmt")) updated = yield* apply$3(cwd, esm, updated);
 	if (toppings.includes("knip")) updated = yield* apply$5(cwd, esm, updated);
 	if (toppings.includes("vscode")) yield* apply(cwd, oxfmtConfigPath(esm));
 	if (toppings.includes("skills")) yield* apply$1(cwd);
+	if (toppings.includes("github-actions")) yield* apply$7(cwd, pm, updated, ciJobs);
 	return updated;
 });
 const persistScripts = Effect.fn("brew.persistScripts")(function* (pkgPath, pkg, updated) {
@@ -999,7 +1172,7 @@ const setupCommitGate = Effect.fn("brew.setupCommitGate")(function* (cwd, pm, es
 		const seededHook = path.join(cwd, ".husky", "pre-commit");
 		if (!huskyExisted && (yield* fs.exists(seededHook))) yield* fs.remove(seededHook);
 	}
-	yield* apply$7(cwd, pm);
+	yield* apply$8(cwd, pm);
 });
 const commitChanges = Effect.fn("brew.commitChanges")(function* (cwd) {
 	const git = yield* Git;
@@ -1028,14 +1201,14 @@ const brew = (cwd = process.cwd()) => Effect.gen(function* () {
 	const pm = yield* detectPm(cwd);
 	yield* Effect.logDebug(`detected package manager: ${pm}`);
 	const { pkg, pkgPath } = yield* readPkg(cwd);
-	const { toppings, sweetness } = yield* askRecipe();
-	yield* Effect.logDebug(`recipe: toppings=[${toppings.join(", ")}] sweetness=${sweetness} esm=${isEsm(pkg)}`);
+	const { toppings, ciJobs, sweetness } = yield* askRecipe();
+	yield* Effect.logDebug(`recipe: toppings=[${toppings.join(", ")}] ciJobs=[${ciJobs.join(", ")}] sweetness=${sweetness} esm=${isEsm(pkg)}`);
 	yield* ensureRepoRootForHooks(cwd, sweetness);
 	const packages = planPackages(pkg, toppings, sweetness, bundledVersions);
 	yield* Effect.logDebug(`planned packages: ${packages.length > 0 ? packages.join(", ") : "(none)"}`);
 	yield* installPackages(pm, cwd, packages);
 	const { pkg: installedPkg } = yield* readPkg(cwd);
-	const updated = yield* applyToppings(cwd, isEsm(installedPkg), installedPkg, toppings);
+	const updated = yield* applyToppings(cwd, pm, isEsm(installedPkg), installedPkg, toppings, ciJobs);
 	yield* persistScripts(pkgPath, installedPkg, updated);
 	yield* setupCommitGate(cwd, pm, isEsm(installedPkg), toppings, sweetness);
 	yield* commitChanges(cwd);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chanom/cli",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "description": "",
   "keywords": [],
   "repository": {
@@ -20,7 +20,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",