@chanom/cli 0.1.1 → 0.2.1

package/README.md

@@ -46,13 +46,18 @@ Based on your answers, `brew` will:
 
 - Initialize a git repo if one doesn't exist yet (with a `.gitignore`)
 - Detect your package manager (`pnpm`, `npm`, `yarn`, or `bun`) - the `packageManager` field in `package.json` wins over the invoking user agent, falling back to `pnpm`
-- Install the packages needed for your selected toppings as dev dependencies
+- Install the packages needed for your selected toppings as dev dependencies - when run at a workspace root (a `pnpm-workspace.yaml` or a `workspaces` field in `package.json`), the install gets the flag your package manager needs: `-w` for pnpm, `-W` for yarn classic, none for npm, bun, and yarn berry
 - Write config files and wire up `package.json` scripts
 - If `medium` sweetness is selected, run `husky init` and add `pre-commit` / `commit-msg` hooks
 - Stage and commit the changes it made
 
 Cancelling a prompt (Ctrl+C) exits cleanly without touching anything further.
 
+`medium` sweetness must be brewed at the git repository root - husky can only
+install hooks from the directory that holds `.git`. Run inside a subdirectory
+(e.g. a workspace package), `brew` stops with an error naming the root before
+installing anything. `light` sweetness works anywhere in the repo.
+
 ## What gets added
 
 | Topping  | Config file          | Scripts added            |
@@ -71,6 +76,10 @@ Config files re-export presets from [`@chanom/dev-config`](../dev-config).
 - `lint-staged` - `.lintstagedrc.json` running the selected linter/formatter on staged files, wired into the `pre-commit` hook
 - `commitlint` - `.commitlintrc.json` extending `@commitlint/config-conventional`, enforced in the `commit-msg` hook
 
+When neither `oxlint` nor `oxfmt` is selected, lint-staged is skipped entirely
+(an empty config would fail every commit) and the `npm test` pre-commit hook
+seeded by `husky init` is removed - only the `commit-msg` gate remains.
+
 ## Version pinning
 
 The CLI bundles the tool versions its generated configs are known to work with (baked in at build time). `oxlint`, `oxfmt`, and `@chanom/dev-config` are (re)installed whenever the installed version doesn't match the pinned one exactly - in either direction, since the generated config must match. `knip`, `husky`, `lint-staged`, and the commitlint packages are only installed when missing.

package/dist/index.js

@@ -6,9 +6,9 @@ import pc from "picocolors";
 import * as clack from "@clack/prompts";
 //#region src/bundled-versions.ts
 const bundledVersions = {
-	oxlint: "1.71.0",
-	oxfmt: "0.56.0",
-	knip: "6.23.0",
+	oxlint: "1.73.0",
+	oxfmt: "0.58.0",
+	knip: "6.26.0",
 	devConfig: "0.0.3"
 };
 //#endregion
@@ -101,22 +101,92 @@ var Git = class extends Effect.Service()("cli/Git", { effect: Effect.gen(functio
 			"--cached",
 			"--quiet"
 		], cwd).pipe(Effect.map((clean) => !clean)),
-		isRepo: (cwd) => fs.exists(path.join(cwd, ".git")),
+		/**
+		* 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 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));
+}
+/**
+* Extra `add` flags needed when installing at a workspace root: pnpm and yarn
+* classic refuse root installs without `-w` / `-W`. npm, bun, and yarn berry
+* install to the root with no flag (npm's `-w` targets a child workspace instead).
+*/
+function workspaceRootFlags(pm, hints) {
+	switch (pm) {
+		case "pnpm": return hints.hasPnpmWorkspaceFile ? ["-w"] : [];
+		case "yarn": return hints.hasWorkspacesField && !hints.hasYarnBerryConfig ? ["-W"] : [];
+		case "npm":
+		case "bun": return [];
+	}
+}
+/** 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 src/services/package-installer.ts
 var InstallFailed = class extends Data.TaggedError("InstallFailed") {};
-/** Installs npm packages with the detected package manager. */
+/**
+* Installs npm packages with the detected package manager, adding the
+* workspace-root flag (pnpm `-w`, yarn classic `-W`) when the target
+* directory is a workspace root.
+*/
 var PackageInstaller = class extends Effect.Service()("cli/PackageInstaller", { effect: Effect.gen(function* () {
 	const runner = yield* CommandRunner;
-	return { installDev: (pm, cwd, packages) => runner.execInherit(pm, [
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const has = (cwd, file) => fs.exists(path.join(cwd, file)).pipe(Effect.orElseSucceed(() => false));
+	const hasWorkspacesField = (cwd) => fs.readFileString(path.join(cwd, "package.json")).pipe(Effect.flatMap((contents) => Effect.try(() => JSON.parse(contents).workspaces !== void 0)), Effect.orElseSucceed(() => false));
+	const workspaceHints = (cwd) => Effect.all({
+		hasPnpmWorkspaceFile: has(cwd, "pnpm-workspace.yaml"),
+		hasWorkspacesField: hasWorkspacesField(cwd),
+		hasYarnBerryConfig: has(cwd, ".yarnrc.yml")
+	}, { concurrency: 3 });
+	return { installDev: (pm, cwd, packages) => workspaceHints(cwd).pipe(Effect.flatMap((hints) => runner.execInherit(pm, [
 		"add",
 		"-D",
+		...workspaceRootFlags(pm, hints),
 		...packages
-	], cwd).pipe(Effect.filterOrFail((code) => code === 0, () => new InstallFailed({ pm })), Effect.asVoid) };
+	], cwd)), Effect.filterOrFail((code) => code === 0, () => new InstallFailed({ pm })), Effect.asVoid) };
 }) }) {};
 //#endregion
 //#region src/services/prompter.ts
@@ -148,40 +218,6 @@ var Prompter = class extends Effect.Service()("cli/Prompter", { succeed: {
 	})
 } }) {};
 //#endregion
-//#region 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 src/utils/detect-pm.ts
 const detectPm = (cwd, userAgent = process.env["npm_config_user_agent"], fallback = "pnpm") => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
@@ -286,7 +322,7 @@ function commitMsgHook(pm) {
 }
 //#endregion
 //#region src/commands/add-commitlint/index.ts
-const apply$5 = (cwd, pm) => Effect.gen(function* () {
+const apply$5 = Effect.fn("add-commitlint.apply")(function* (cwd, pm) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -299,7 +335,7 @@ const apply$5 = (cwd, pm) => Effect.gen(function* () {
 		if (yield* fs.exists(hookPath)) yield* prompter.warn("`.husky/commit-msg` already exists - skipping");
 		else yield* fs.writeFileString(hookPath, commitMsgHook(pm));
 	}
-}).pipe(Effect.withSpan("add-commitlint.apply"));
+});
 //#endregion
 //#region src/commands/add-husky/logic.ts
 function getPackages$4(pkg) {
@@ -308,7 +344,7 @@ function getPackages$4(pkg) {
 //#endregion
 //#region src/commands/add-husky/index.ts
 var HuskyInitFailed = class extends Data.TaggedError("HuskyInitFailed") {};
-const apply$4 = (cwd, pm) => Effect.gen(function* () {
+const apply$4 = Effect.fn("add-husky.apply")(function* (cwd, pm) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -325,7 +361,7 @@ const apply$4 = (cwd, pm) => Effect.gen(function* () {
 		"init"
 	], cwd);
 	if (exitCode !== 0) return yield* new HuskyInitFailed({ exitCode });
-}).pipe(Effect.withSpan("add-husky.apply"));
+});
 //#endregion
 //#region src/domain/scripts.ts
 /**
@@ -364,7 +400,7 @@ function getScriptPlan$2(scripts) {
 //#endregion
 //#region src/commands/add-knip/index.ts
 /** Returns a copy of `pkg` with missing scripts added; the caller owns writing package.json. */
-const apply$3 = (cwd, esm, pkg) => Effect.gen(function* () {
+const apply$3 = Effect.fn("add-knip.apply")(function* (cwd, esm, pkg) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -380,7 +416,7 @@ const apply$3 = (cwd, esm, pkg) => Effect.gen(function* () {
 		...pkg,
 		scripts: plan.scripts
 	};
-}).pipe(Effect.withSpan("add-knip.apply"));
+});
 //#endregion
 //#region src/commands/add-lint-staged/logic.ts
 function getPackages$2(pkg) {
@@ -401,7 +437,11 @@ function buildConfig(linters, formatters) {
 }
 //#endregion
 //#region src/commands/add-lint-staged/index.ts
-const apply$2 = (cwd, linters = [], formatters = [], overwritePreCommit = false) => Effect.gen(function* () {
+const apply$2 = Effect.fn("add-lint-staged.apply")(function* (cwd, linters = [], formatters = [], overwritePreCommit = false) {
+	if (linters.length === 0 && formatters.length === 0) {
+		yield* Effect.logDebug("no linters or formatters selected - skipping lint-staged setup");
+		return;
+	}
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -414,7 +454,7 @@ const apply$2 = (cwd, linters = [], formatters = [], overwritePreCommit = false)
 		if ((yield* fs.exists(hookPath)) && !overwritePreCommit) yield* prompter.warn("`.husky/pre-commit` already exists - skipping");
 		else yield* fs.writeFileString(hookPath, "lint-staged\n");
 	}
-}).pipe(Effect.withSpan("add-lint-staged.apply"));
+});
 //#endregion
 //#region src/commands/add-oxfmt/logic.ts
 function getPackages$1(pkg, versions) {
@@ -435,7 +475,7 @@ function getScriptPlan$1(scripts) {
 //#endregion
 //#region src/commands/add-oxfmt/index.ts
 /** Returns a copy of `pkg` with missing scripts added; the caller owns writing package.json. */
-const apply$1 = (cwd, esm, pkg) => Effect.gen(function* () {
+const apply$1 = Effect.fn("add-oxfmt.apply")(function* (cwd, esm, pkg) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -451,7 +491,7 @@ const apply$1 = (cwd, esm, pkg) => Effect.gen(function* () {
 		...pkg,
 		scripts: plan.scripts
 	};
-}).pipe(Effect.withSpan("add-oxfmt.apply"));
+});
 //#endregion
 //#region src/commands/add-oxlint/logic.ts
 function getPackages(pkg, versions) {
@@ -472,7 +512,7 @@ function getScriptPlan(scripts) {
 //#endregion
 //#region src/commands/add-oxlint/index.ts
 /** Returns a copy of `pkg` with missing scripts added; the caller owns writing package.json. */
-const apply = (cwd, esm, pkg) => Effect.gen(function* () {
+const apply = Effect.fn("add-oxlint.apply")(function* (cwd, esm, pkg) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -488,7 +528,7 @@ const apply = (cwd, esm, pkg) => Effect.gen(function* () {
 		...pkg,
 		scripts: plan.scripts
 	};
-}).pipe(Effect.withSpan("add-oxlint.apply"));
+});
 //#endregion
 //#region src/commands/brew/logic.ts
 /** Deduplicated list of packages to install for the chosen toppings and sweetness. */
@@ -497,9 +537,17 @@ function planPackages(pkg, toppings, sweetness, versions) {
 	if (toppings.includes("oxlint")) packages.push(...getPackages(pkg, versions));
 	if (toppings.includes("oxfmt")) packages.push(...getPackages$1(pkg, versions));
 	if (toppings.includes("knip")) packages.push(...getPackages$3(pkg, versions));
-	if (sweetness === "medium") packages.push(...getPackages$4(pkg), ...getPackages$2(pkg), ...getPackages$5(pkg));
+	if (sweetness === "medium") {
+		packages.push(...getPackages$4(pkg));
+		if (wantsLintStaged(toppings)) packages.push(...getPackages$2(pkg));
+		packages.push(...getPackages$5(pkg));
+	}
 	return [...new Set(packages)];
 }
+/** True when at least one topping gives lint-staged something to run. */
+function wantsLintStaged(toppings) {
+	return selectedLinters(toppings).length > 0 || selectedFormatters(toppings).length > 0;
+}
 /** True when the .gitignore content already has the entry as its own line. */
 function hasGitignoreEntry(content, entry) {
 	const forms = /* @__PURE__ */ new Set([
@@ -523,7 +571,8 @@ function selectedFormatters(toppings) {
 }
 //#endregion
 //#region src/commands/brew/index.ts
-const ensureGitRepo = (cwd) => Effect.gen(function* () {
+var NotAtRepoRoot = class extends Data.TaggedError("NotAtRepoRoot") {};
+const ensureGitRepo = Effect.fn("brew.ensureGitRepo")(function* (cwd) {
 	const git = yield* Git;
 	if (yield* git.isRepo(cwd)) {
 		yield* Effect.logDebug("git repository already present");
@@ -532,8 +581,8 @@ const ensureGitRepo = (cwd) => Effect.gen(function* () {
 	const s = yield* (yield* Prompter).spinner("Git not found, initializing repository...");
 	yield* git.init(cwd);
 	yield* s.stop("Git initialized");
-}).pipe(Effect.withSpan("brew.ensureGitRepo"));
-const ensureGitIgnore = (cwd) => Effect.gen(function* () {
+});
+const ensureGitIgnore = Effect.fn("brew.ensureGitIgnore")(function* (cwd) {
 	const git = yield* Git;
 	const prompter = yield* Prompter;
 	const existing = yield* git.readGitignore(cwd).pipe(Effect.catchTag("SystemError", (e) => e.reason === "NotFound" ? Effect.succeed(void 0) : Effect.fail(e)));
@@ -544,8 +593,8 @@ const ensureGitIgnore = (cwd) => Effect.gen(function* () {
 	const s = yield* prompter.spinner(existing === void 0 ? "Creating .gitignore..." : "Adding node_modules to .gitignore...");
 	yield* git.writeGitignore(cwd, appendGitignoreEntry(existing ?? "", "node_modules")).pipe(Effect.tapError(() => s.stop(pc.red("Could not update .gitignore"))));
 	yield* s.stop(existing === void 0 ? ".gitignore created" : "node_modules added to .gitignore");
-}).pipe(Effect.withSpan("brew.ensureGitIgnore"));
-const askRecipe = () => Effect.gen(function* () {
+});
+const askRecipe = Effect.fn("brew.askRecipe")(function* () {
 	const prompter = yield* Prompter;
 	return {
 		toppings: yield* prompter.multiselect({
@@ -582,8 +631,8 @@ const askRecipe = () => Effect.gen(function* () {
 			}]
 		})
 	};
-}).pipe(Effect.withSpan("brew.askRecipe"));
-const installPackages = (pm, cwd, packages) => Effect.gen(function* () {
+});
+const installPackages = Effect.fn("brew.installPackages")(function* (pm, cwd, packages) {
 	if (packages.length === 0) {
 		yield* Effect.logDebug("no packages to install");
 		return;
@@ -593,30 +642,53 @@ const installPackages = (pm, cwd, packages) => Effect.gen(function* () {
 	const s = yield* prompter.spinner(`Installing ${packages.join(", ")}...`);
 	yield* installer.installDev(pm, cwd, packages).pipe(Effect.tapError(() => s.stop(pc.red("Package installation failed"))));
 	yield* s.stop("Packages installed");
-}).pipe(Effect.withSpan("brew.installPackages"));
-const applyToppings = (cwd, esm, pkg, toppings) => Effect.gen(function* () {
+});
+const applyToppings = Effect.fn("brew.applyToppings")(function* (cwd, esm, pkg, toppings) {
 	let updated = pkg;
 	if (toppings.includes("oxlint")) updated = yield* apply(cwd, esm, updated);
 	if (toppings.includes("oxfmt")) updated = yield* apply$1(cwd, esm, updated);
 	if (toppings.includes("knip")) updated = yield* apply$3(cwd, esm, updated);
 	return updated;
-}).pipe(Effect.withSpan("brew.applyToppings"));
-const persistScripts = (pkgPath, pkg, updated) => Effect.gen(function* () {
-	if (JSON.stringify(updated.scripts ?? {}) !== JSON.stringify(pkg.scripts ?? {})) {
+});
+const persistScripts = Effect.fn("brew.persistScripts")(function* (pkgPath, pkg, updated) {
+	if (JSON.stringify(updated.scripts ?? {}) === JSON.stringify(pkg.scripts ?? {})) yield* Effect.logDebug("scripts unchanged, skipping package.json write");
+	else {
 		yield* Effect.logDebug(`writing updated scripts to ${pkgPath}`);
 		yield* writePkg(pkgPath, updated);
-	} else yield* Effect.logDebug("scripts unchanged, skipping package.json write");
-}).pipe(Effect.withSpan("brew.persistScripts"));
-const setupCommitGate = (cwd, pm, toppings, sweetness) => Effect.gen(function* () {
+	}
+});
+/**
+* Fails when medium sweetness is chosen away from the git work-tree root:
+* husky can only install hooks from the directory that holds `.git`, so
+* running it in e.g. a workspace package would leave hooks that never fire.
+*/
+const ensureRepoRootForHooks = Effect.fn("brew.ensureRepoRootForHooks")(function* (cwd, sweetness) {
+	if (sweetness !== "medium") return;
+	const git = yield* Git;
+	const prefix = yield* git.prefix(cwd);
+	if (Option.isNone(prefix) || prefix.value === "") return;
+	const root = yield* git.root(cwd);
+	return yield* new NotAtRepoRoot({
+		cwd,
+		root: Option.getOrElse(root, () => cwd)
+	});
+});
+const setupCommitGate = Effect.fn("brew.setupCommitGate")(function* (cwd, pm, toppings, sweetness) {
 	if (sweetness !== "medium") return;
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
+	const prompter = yield* Prompter;
 	const huskyExisted = yield* fs.exists(path.join(cwd, ".husky"));
 	yield* apply$4(cwd, pm);
-	yield* apply$2(cwd, selectedLinters(toppings), selectedFormatters(toppings), !huskyExisted);
+	if (wantsLintStaged(toppings)) yield* apply$2(cwd, selectedLinters(toppings), selectedFormatters(toppings), !huskyExisted);
+	else {
+		yield* prompter.warn("No linters or formatters selected - skipping lint-staged");
+		const seededHook = path.join(cwd, ".husky", "pre-commit");
+		if (!huskyExisted && (yield* fs.exists(seededHook))) yield* fs.remove(seededHook);
+	}
 	yield* apply$5(cwd, pm);
-}).pipe(Effect.withSpan("brew.setupCommitGate"));
-const commitChanges = (cwd) => Effect.gen(function* () {
+});
+const commitChanges = Effect.fn("brew.commitChanges")(function* (cwd) {
 	const git = yield* Git;
 	const prompter = yield* Prompter;
 	const s = yield* prompter.spinner("Committing changes...");
@@ -634,7 +706,7 @@ const commitChanges = (cwd) => Effect.gen(function* () {
 	yield* s.stop(pc.yellow("Could not commit changes automatically"));
 	const detail = result.stderr || result.stdout;
 	yield* prompter.warn(`${detail ? detail + "\n" : ""}Your files are staged - commit them manually when ready.`);
-}).pipe(Effect.withSpan("brew.commitChanges"));
+});
 const brew = (cwd = process.cwd()) => Effect.gen(function* () {
 	const prompter = yield* Prompter;
 	yield* prompter.intro(pc.magenta("🧋 Chanom - Let's brew your project!"));
@@ -645,10 +717,12 @@ const brew = (cwd = process.cwd()) => Effect.gen(function* () {
 	const { pkg, pkgPath } = yield* readPkg(cwd);
 	const { toppings, sweetness } = yield* askRecipe();
 	yield* Effect.logDebug(`recipe: toppings=[${toppings.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);
-	yield* persistScripts(pkgPath, pkg, yield* applyToppings(cwd, isEsm(pkg), pkg, toppings));
+	const { pkg: installedPkg } = yield* readPkg(cwd);
+	yield* persistScripts(pkgPath, installedPkg, yield* applyToppings(cwd, isEsm(installedPkg), installedPkg, toppings));
 	yield* setupCommitGate(cwd, pm, toppings, sweetness);
 	yield* commitChanges(cwd);
 	yield* prompter.outro(pc.green(`Your Chanom with ${toppings.join(", ")} toppings and ${sweetness} sweetness is ready! Enjoy! 🧋`));
@@ -680,7 +754,8 @@ const run = (name, cwd = process.cwd(), options = {}) => {
 		PkgNotFound: (e) => reportError(`No package.json found in ${e.cwd}. Run this inside a project.`),
 		PkgInvalid: (e) => reportError(`Could not parse ${e.pkgPath}. Is it valid JSON?`),
 		InstallFailed: (e) => reportError(`Package installation with ${e.pm} failed.`),
-		HuskyInitFailed: (e) => reportError(`\`husky init\` failed (exit code ${e.exitCode}).`)
+		HuskyInitFailed: (e) => reportError(`\`husky init\` failed (exit code ${e.exitCode}).`),
+		NotAtRepoRoot: (e) => reportError(`Git hooks must be set up at the repository root: ${e.root}\nRun \`chanom brew\` there, or choose light sweetness.`)
 	}), Effect.catchAll((e) => reportError(`Unexpected error: ${e.message}`)), Logger.withMinimumLogLevel(debug ? LogLevel.Debug : LogLevel.Info));
 };
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chanom/cli",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "",
   "keywords": [],
   "repository": {
@@ -28,6 +28,7 @@
     "@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",
@@ -37,6 +38,7 @@
     "build": "tsdown",
     "dev": "tsdown --watch",
     "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
     "test:watch": "vitest"
   }
 }