@chanom/cli 0.2.0 → 0.2.1

package/README.md

@@ -53,6 +53,11 @@ Based on your answers, `brew` will:
 
 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,7 +101,16 @@ 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"))
 	};
@@ -429,6 +438,10 @@ function buildConfig(linters, formatters) {
 //#endregion
 //#region src/commands/add-lint-staged/index.ts
 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;
@@ -524,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([
@@ -550,6 +571,7 @@ function selectedFormatters(toppings) {
 }
 //#endregion
 //#region src/commands/brew/index.ts
+var NotAtRepoRoot = class extends Data.TaggedError("NotAtRepoRoot") {};
 const ensureGitRepo = Effect.fn("brew.ensureGitRepo")(function* (cwd) {
 	const git = yield* Git;
 	if (yield* git.isRepo(cwd)) {
@@ -635,13 +657,35 @@ const persistScripts = Effect.fn("brew.persistScripts")(function* (pkgPath, pkg,
 		yield* writePkg(pkgPath, updated);
 	}
 });
+/**
+* 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);
 });
 const commitChanges = Effect.fn("brew.commitChanges")(function* (cwd) {
@@ -673,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! 🧋`));
@@ -708,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.2.0",
+  "version": "0.2.1",
   "description": "",
   "keywords": [],
   "repository": {