@chanom/cli 0.0.3 → 0.1.1

package/README.md

@@ -24,9 +24,17 @@ pnpm add -D @chanom/cli
 chanom brew
 ```
 
+Add `--debug` to trace what the CLI is doing and see exactly where it failed:
+
+```sh
+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:
 
-1. **Toppings** - which tools to add, any combination of:
+1. **Toppings** - which tools to add, any combination (or none):
    - `oxlint` - fast Rust-based linter
    - `oxfmt` - fast Rust-based formatter
    - `knip` - dead code remover
@@ -37,26 +45,52 @@ chanom brew
 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`) from `package.json`/`packageManager` or the invoking user agent
-- Install the packages needed for your selected toppings, skipping any already installed
-- Write config files (`oxlint.config.ts`, `oxfmt.config.ts`, `knip.config.ts`, `.commitlintrc.json`, `.lintstagedrc.json`) and wire up `package.json` scripts
+- 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
+- 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.
+
 ## 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`                   |
+| Topping  | Config file          | Scripts added            |
+| -------- | -------------------- | ------------------------ |
+| `oxlint` | `oxlint.config.ts`\* | `lint`, `lint:fix`       |
+| `oxfmt`  | `oxfmt.config.ts`\*  | `format`, `format:check` |
+| `knip`   | `knip.config.ts`\*   | `knip`                   |
+
+\* `.mts` instead of `.ts` when your project is CommonJS (no `"type": "module"` in `package.json`).
 
 Config files re-export presets from [`@chanom/dev-config`](../dev-config).
 
 `medium` sweetness additionally adds:
 
 - `husky` - installed via `husky init`
-- `lint-staged` - `.lintstagedrc.json` running the selected linter/formatter on staged files
+- `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
 
-Existing scripts and config are never overwritten - if a script name already exists in `package.json`, `brew` logs a warning and leaves it alone.
+## 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.
+
+## Safety
+
+Existing setup is never overwritten:
+
+- If a config file for a tool already exists (any common variant, e.g. `.oxlintrc.json` or `oxlint.config.mjs`), `brew` warns and skips writing it.
+- If a script name already exists in `package.json`, `brew` warns and leaves it alone.
+- Existing `.husky/pre-commit` and `.husky/commit-msg` hooks are kept.
+
+The final commit uses your git identity; if none is configured, a local `Chanom <chanom@local>` identity is set. If committing fails (e.g. a commit hook rejects it), your files stay staged and `brew` tells you to commit manually.
+
+## Development
+
+See [ARCHITECTURE.md](./ARCHITECTURE.md) for how the code is organized.
+
+```sh
+pnpm build      # bundle with tsdown
+pnpm test       # run vitest once
+pnpm test:watch # run vitest in watch mode
+```

package/dist/index.js

@@ -1,10 +1,154 @@
 #!/usr/bin/env node
-import { intro, log, multiselect, outro, select, spinner } from "@clack/prompts";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, join } from "node:path";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { Cause, Chunk, Data, Effect, Layer, LogLevel, Logger, Option, Stream } from "effect";
+import { Command, CommandExecutor, FileSystem, Path } from "@effect/platform";
 import pc from "picocolors";
-import { spawnSync } from "node:child_process";
-//#region src/utils/detect-pm.ts
+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",
+	devConfig: "0.0.3"
+};
+//#endregion
+//#region src/domain/pkg.ts
+var PkgNotFound = class extends Data.TaggedError("PkgNotFound") {};
+var PkgInvalid = class extends Data.TaggedError("PkgInvalid") {};
+function isEsm(pkg) {
+	return pkg.type === "module";
+}
+function isPackageInstalled(pkg, name) {
+	return name in (pkg.dependencies ?? {}) || name in (pkg.devDependencies ?? {});
+}
+function stripRangePrefix(version) {
+	return version.replace(/^[\^~]/, "");
+}
+function getMismatchedPackage(pkg, name, version) {
+	const installed = pkg.dependencies?.[name] ?? pkg.devDependencies?.[name];
+	return installed !== void 0 && stripRangePrefix(installed) === version ? void 0 : `${name}@${version}`;
+}
+//#endregion
+//#region 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()("cli/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 src/services/git.ts
+/** Git operations, built on top of {@link CommandRunner}. */
+var Git = class extends Effect.Service()("cli/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)),
+		isRepo: (cwd) => fs.exists(path.join(cwd, ".git")),
+		writeGitignore: (cwd, contents = "node_modules\n") => fs.writeFileString(path.join(cwd, ".gitignore"), contents),
+		readGitignore: (cwd) => fs.readFileString(path.join(cwd, ".gitignore"))
+	};
+}) }) {};
+//#endregion
+//#region src/services/package-installer.ts
+var InstallFailed = class extends Data.TaggedError("InstallFailed") {};
+/** Installs npm packages with the detected package manager. */
+var PackageInstaller = class extends Effect.Service()("cli/PackageInstaller", { effect: Effect.gen(function* () {
+	const runner = yield* CommandRunner;
+	return { installDev: (pm, cwd, packages) => runner.execInherit(pm, [
+		"add",
+		"-D",
+		...packages
+	], cwd).pipe(Effect.filterOrFail((code) => code === 0, () => new InstallFailed({ pm })), Effect.asVoid) };
+}) }) {};
+//#endregion
+//#region 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()("cli/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)),
+	debug: (message) => Effect.sync(() => clack.log.message(pc.dim(message))),
+	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/domain/package-manager.ts
 /** How to run a locally installed binary with each package manager. */
 const PM_EXEC = {
 	pnpm: ["pnpm", "exec"],
@@ -22,115 +166,53 @@ const KNOWN_PMS = [
 	"bun",
 	"npm"
 ];
-function fromPkgJson(cwd) {
-	const pkgPath = join(cwd, "package.json");
-	if (!existsSync(pkgPath)) return void 0;
-	try {
-		const { packageManager } = JSON.parse(readFileSync(pkgPath, "utf-8"));
-		if (!packageManager) return void 0;
-		const name = packageManager.split("@")[0];
-		return KNOWN_PMS.includes(name) ? name : void 0;
-	} catch {
-		return;
-	}
-}
-function fromUserAgent() {
-	const agent = process.env["npm_config_user_agent"];
+/** 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));
 }
-function detectPm(cwd = process.cwd(), defaultPm = "pnpm") {
-	return fromPkgJson(cwd) ?? fromUserAgent() ?? defaultPm;
+/** 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/git.ts
-function run(args, cwd) {
-	const { status, stdout, stderr } = spawnSync("git", args, {
-		stdio: "pipe",
-		cwd,
-		encoding: "utf-8"
+//#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;
+	const pkgPath = (yield* Path.Path).join(cwd, "package.json");
+	return resolvePm({
+		packageManagerField: yield* fs.readFileString(pkgPath).pipe(Effect.flatMap((contents) => Effect.try(() => JSON.parse(contents).packageManager)), Effect.orElseSucceed(() => void 0)),
+		userAgent,
+		fallback
 	});
-	return {
-		ok: status === 0,
-		stdout: (stdout ?? "").trim(),
-		stderr: (stderr ?? "").trim()
-	};
-}
-function isGitRepo(cwd = process.cwd()) {
-	return existsSync(join(cwd, ".git"));
-}
-function init(cwd) {
-	return run(["init"], cwd);
-}
-/** True if git has a usable author identity (committer.name + committer.email). */
-function hasIdentity(cwd) {
-	return run(["var", "GIT_COMMITTER_IDENT"], cwd).ok;
-}
-/** Set a repo-local identity so commits succeed on a fresh repo without global config. */
-function setLocalIdentity(cwd, name, email) {
-	run([
-		"config",
-		"user.name",
-		name
-	], cwd);
-	run([
-		"config",
-		"user.email",
-		email
-	], cwd);
-}
-function stageAll(cwd) {
-	return run(["add", "."], cwd);
-}
-/** True if there is anything staged to commit. */
-function hasStagedChanges(cwd) {
-	return !run([
-		"diff",
-		"--cached",
-		"--quiet"
-	], cwd).ok;
-}
-function commit(cwd, message) {
-	return run([
-		"commit",
-		"-m",
-		message
-	], cwd);
-}
-function writeGitignore(cwd, contents = "node_modules\n") {
-	writeFileSync(join(cwd, ".gitignore"), contents, "utf-8");
-}
+});
 //#endregion
-//#region src/utils/install.ts
-function installDev(pm, cwd, ...packages) {
-	return spawnSync(pm, [
-		"add",
-		"-D",
-		...packages
-	], {
-		stdio: "inherit",
-		cwd
-	}).status === 0;
-}
-//#endregion
-//#region src/utils/pkg.ts
-function isEsm(pkg) {
-	return pkg.type === "module";
-}
-function readPkg(cwd) {
-	const pkgPath = join(cwd, "package.json");
-	if (!existsSync(pkgPath)) throw new Error(`No package.json found in ${cwd}`);
+//#region src/utils/pkg-file.ts
+const readPkg = (cwd) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const pkgPath = (yield* Path.Path).join(cwd, "package.json");
+	if (!(yield* fs.exists(pkgPath))) return yield* new PkgNotFound({ cwd });
+	const contents = yield* fs.readFileString(pkgPath);
 	return {
-		pkg: JSON.parse(readFileSync(pkgPath, "utf-8")),
+		pkg: yield* Effect.try({
+			try: () => JSON.parse(contents),
+			catch: () => new PkgInvalid({ pkgPath })
+		}),
 		pkgPath
 	};
-}
-function isPackageInstalled(pkg, name) {
-	return name in (pkg.dependencies ?? {}) || name in (pkg.devDependencies ?? {});
-}
+});
+const writePkg = (pkgPath, pkg) => Effect.gen(function* () {
+	yield* (yield* FileSystem.FileSystem).writeFileString(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+});
 //#endregion
-//#region src/utils/detect-setup.ts
-const CONFIG_FILES = {
+//#region src/domain/setup.ts
+const SETUP_FILE_CANDIDATES = {
 	oxlint: [
 		"oxlint.config.js",
 		"oxlint.config.cjs",
@@ -173,258 +255,448 @@ const CONFIG_FILES = {
 		"vite.config.mjs"
 	]
 };
-function detectSetupFile(type, cwd = process.cwd()) {
-	for (const filename of CONFIG_FILES[type]) {
-		const filepath = join(cwd, filename);
-		if (existsSync(filepath)) return filepath;
+//#endregion
+//#region src/utils/detect-setup.ts
+/** Finds an existing config file for the given tool, if any. */
+const detectSetupFile = (type, cwd) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	for (const candidate of SETUP_FILE_CANDIDATES[type]) {
+		const filepath = path.join(cwd, candidate);
+		if (yield* fs.exists(filepath)) return Option.some(filepath);
 	}
-	return null;
-}
+	return Option.none();
+});
 //#endregion
-//#region src/commands/add-commitlint/index.ts
+//#region src/commands/add-commitlint/logic.ts
 function getPackages$5(pkg) {
 	const missing = [];
 	if (!isPackageInstalled(pkg, "@commitlint/cli")) missing.push("@commitlint/cli");
 	if (!isPackageInstalled(pkg, "@commitlint/config-conventional")) missing.push("@commitlint/config-conventional");
 	return missing;
 }
-function apply$5(cwd, pm) {
-	const existing = detectSetupFile("commitlint", cwd);
-	if (existing) log.warn(`\`${basename(existing)}\` already exists - skipping commitlint config`);
-	else writeFileSync(join(cwd, ".commitlintrc.json"), JSON.stringify({ extends: ["@commitlint/config-conventional"] }, null, 2) + "\n");
-	if (existsSync(join(cwd, ".husky"))) {
-		const hookPath = join(cwd, ".husky", "commit-msg");
-		if (existsSync(hookPath)) log.warn("`.husky/commit-msg` already exists - skipping");
-		else writeFileSync(hookPath, [
-			...PM_EXEC[pm],
-			"commitlint",
-			"--edit",
-			"$1"
-		].join(" ") + "\n");
-	}
+const CONFIG_CONTENTS = JSON.stringify({ extends: ["@commitlint/config-conventional"] }, null, 2) + "\n";
+function commitMsgHook(pm) {
+	return [
+		...PM_EXEC[pm],
+		"commitlint",
+		"--edit",
+		"$1"
+	].join(" ") + "\n";
 }
 //#endregion
-//#region src/commands/add-husky/index.ts
+//#region src/commands/add-commitlint/index.ts
+const apply$5 = (cwd, pm) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const prompter = yield* Prompter;
+	const existing = yield* detectSetupFile("commitlint", cwd);
+	if (Option.isSome(existing)) yield* prompter.warn(`\`${path.basename(existing.value)}\` already exists - skipping commitlint config`);
+	else yield* fs.writeFileString(path.join(cwd, ".commitlintrc.json"), CONFIG_CONTENTS);
+	const huskyDir = path.join(cwd, ".husky");
+	if (yield* fs.exists(huskyDir)) {
+		const hookPath = path.join(huskyDir, "commit-msg");
+		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) {
 	return isPackageInstalled(pkg, "husky") ? [] : ["husky"];
 }
-function apply$4(cwd, pm) {
-	if (existsSync(join(cwd, ".husky"))) {
-		log.warn("`.husky` already exists - skipping husky init");
+//#endregion
+//#region src/commands/add-husky/index.ts
+var HuskyInitFailed = class extends Data.TaggedError("HuskyInitFailed") {};
+const apply$4 = (cwd, pm) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const prompter = yield* Prompter;
+	const runner = yield* CommandRunner;
+	const huskyDir = path.join(cwd, ".husky");
+	if (yield* fs.exists(huskyDir)) {
+		yield* prompter.warn("`.husky` already exists - skipping husky init");
 		return;
 	}
 	const [cmd, ...args] = PM_EXEC[pm];
-	spawnSync(cmd, [
+	const exitCode = yield* runner.execInherit(cmd, [
 		...args,
 		"husky",
 		"init"
-	], {
-		stdio: "inherit",
-		cwd
-	});
+	], cwd);
+	if (exitCode !== 0) return yield* new HuskyInitFailed({ exitCode });
+}).pipe(Effect.withSpan("add-husky.apply"));
+//#endregion
+//#region src/domain/scripts.ts
+/**
+* Merges `wanted` scripts into `current` without overwriting anything the user
+* already has. Returns the merged scripts plus which keys were added or skipped.
+*/
+function planScripts(current, wanted) {
+	const scripts = { ...current };
+	const added = [];
+	const skipped = [];
+	for (const [key, value] of Object.entries(wanted)) if (scripts[key]) skipped.push(key);
+	else {
+		scripts[key] = value;
+		added.push(key);
+	}
+	return {
+		scripts,
+		added,
+		skipped
+	};
 }
 //#endregion
 //#region src/commands/add-knip/logic.ts
-function getMissingScripts$2(scripts) {
-	const missing = {};
-	if (!scripts["knip"]) missing["knip"] = "knip";
-	return missing;
+function getPackages$3(pkg, versions) {
+	return isPackageInstalled(pkg, "knip") ? [] : [`knip@${versions.knip}`, `@chanom/dev-config@${versions.devConfig}`];
 }
-//#endregion
-//#region src/commands/add-knip/index.ts
-function getPackages$3(pkg) {
-	return isPackageInstalled(pkg, "knip") ? [] : [`knip@6.23.0`, `@chanom/dev-config@0.0.3`];
+function configFile$2(esm) {
+	return {
+		fileName: `knip.config.${esm ? "ts" : "mts"}`,
+		contents: `export { default } from '@chanom/dev-config/knip/config';\n`
+	};
 }
-function apply$3(cwd, esm) {
-	const existing = detectSetupFile("knip", cwd);
-	if (existing) log.warn(`\`${basename(existing)}\` already exists - skipping knip config`);
-	else writeFileSync(join(cwd, `knip.config.${esm ? "ts" : "mts"}`), `export { default } from '@chanom/dev-config/knip/config';\n`);
-	const { pkg, pkgPath } = readPkg(cwd);
-	pkg.scripts ??= {};
-	const missing = getMissingScripts$2(pkg.scripts);
-	for (const [key, value] of Object.entries(missing)) pkg.scripts[key] = value;
-	const skipped = ["knip"].filter((k) => !(k in missing));
-	for (const key of skipped) log.warn(`\`${key}\` script already exists in package.json - skipping`);
-	if (Object.keys(missing).length > 0) writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+function getScriptPlan$2(scripts) {
+	return planScripts(scripts, { knip: "knip" });
 }
 //#endregion
-//#region src/commands/add-lint-staged/index.ts
+//#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 fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const prompter = yield* Prompter;
+	const existing = yield* detectSetupFile("knip", cwd);
+	if (Option.isSome(existing)) yield* prompter.warn(`\`${path.basename(existing.value)}\` already exists - skipping knip config`);
+	else {
+		const config = configFile$2(esm);
+		yield* fs.writeFileString(path.join(cwd, config.fileName), config.contents);
+	}
+	const plan = getScriptPlan$2(pkg.scripts);
+	for (const key of plan.skipped) yield* prompter.warn(`\`${key}\` script already exists in package.json - skipping`);
+	return {
+		...pkg,
+		scripts: plan.scripts
+	};
+}).pipe(Effect.withSpan("add-knip.apply"));
+//#endregion
+//#region src/commands/add-lint-staged/logic.ts
 function getPackages$2(pkg) {
 	return isPackageInstalled(pkg, "lint-staged") ? [] : ["lint-staged"];
 }
-function apply$2(cwd, linters = [], formatters = [], overwritePreCommit = false) {
-	const existing = detectSetupFile("lint-staged", cwd);
-	if (existing) log.warn(`\`${basename(existing)}\` already exists - skipping lint-staged config`);
-	else {
-		const config = {};
-		const jsGlob = "**/*.{js,jsx,ts,tsx,mjs,cjs,mts,cts}";
-		if (linters.includes("oxlint")) {
-			config[jsGlob] ??= [];
-			config[jsGlob].push("oxlint --fix");
-		}
-		if (formatters.includes("oxfmt")) {
-			config["*"] ??= [];
-			config["*"].push("oxfmt");
-		}
-		writeFileSync(join(cwd, ".lintstagedrc.json"), JSON.stringify(config, null, 2) + "\n");
+function buildConfig(linters, formatters) {
+	const config = {};
+	const jsGlob = "**/*.{js,jsx,ts,tsx,mjs,cjs,mts,cts}";
+	if (linters.includes("oxlint")) {
+		config[jsGlob] ??= [];
+		config[jsGlob].push("oxlint --fix --no-error-on-unmatched-pattern");
 	}
-	if (existsSync(join(cwd, ".husky"))) {
-		const hookPath = join(cwd, ".husky", "pre-commit");
-		if (existsSync(hookPath) && !overwritePreCommit) log.warn("`.husky/pre-commit` already exists - skipping");
-		else writeFileSync(hookPath, "lint-staged\n");
+	if (formatters.includes("oxfmt")) {
+		config["*"] ??= [];
+		config["*"].push("oxfmt --no-error-on-unmatched-pattern");
 	}
+	return config;
 }
 //#endregion
+//#region src/commands/add-lint-staged/index.ts
+const apply$2 = (cwd, linters = [], formatters = [], overwritePreCommit = false) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const prompter = yield* Prompter;
+	const existing = yield* detectSetupFile("lint-staged", cwd);
+	if (Option.isSome(existing)) yield* prompter.warn(`\`${path.basename(existing.value)}\` already exists - skipping lint-staged config`);
+	else yield* fs.writeFileString(path.join(cwd, ".lintstagedrc.json"), JSON.stringify(buildConfig(linters, formatters), null, 2) + "\n");
+	const huskyDir = path.join(cwd, ".husky");
+	if (yield* fs.exists(huskyDir)) {
+		const hookPath = path.join(huskyDir, "pre-commit");
+		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 getMissingScripts$1(scripts) {
-	const missing = {};
-	if (!scripts["format"]) missing["format"] = "oxfmt";
-	if (!scripts["format:check"]) missing["format:check"] = "oxfmt --check";
-	return missing;
+function getPackages$1(pkg, versions) {
+	return [getMismatchedPackage(pkg, "oxfmt", versions.oxfmt), getMismatchedPackage(pkg, "@chanom/dev-config", versions.devConfig)].filter((p) => p !== void 0);
 }
-//#endregion
-//#region src/commands/add-oxfmt/index.ts
-function getPackages$1(pkg) {
-	return isPackageInstalled(pkg, "oxfmt") ? [] : [`oxfmt@0.56.0`, `@chanom/dev-config@0.0.3`];
+function configFile$1(esm) {
+	return {
+		fileName: `oxfmt.config.${esm ? "ts" : "mts"}`,
+		contents: `export { default } from '@chanom/dev-config/oxfmt/config';\n`
+	};
 }
-function apply$1(cwd, esm) {
-	const existing = detectSetupFile("oxfmt", cwd);
-	if (existing) log.warn(`\`${basename(existing)}\` already exists - skipping oxfmt config`);
-	else writeFileSync(join(cwd, `oxfmt.config.${esm ? "ts" : "mts"}`), `export { default } from '@chanom/dev-config/oxfmt/config';\n`);
-	const { pkg, pkgPath } = readPkg(cwd);
-	pkg.scripts ??= {};
-	const missing = getMissingScripts$1(pkg.scripts);
-	for (const [key, value] of Object.entries(missing)) pkg.scripts[key] = value;
-	const skipped = ["format", "format:check"].filter((k) => !(k in missing));
-	for (const key of skipped) log.warn(`\`${key}\` script already exists in package.json - skipping`);
-	if (Object.keys(missing).length > 0) writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+function getScriptPlan$1(scripts) {
+	return planScripts(scripts, {
+		format: "oxfmt",
+		"format:check": "oxfmt --check"
+	});
 }
 //#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 fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const prompter = yield* Prompter;
+	const existing = yield* detectSetupFile("oxfmt", cwd);
+	if (Option.isSome(existing)) yield* prompter.warn(`\`${path.basename(existing.value)}\` already exists - skipping oxfmt config`);
+	else {
+		const config = configFile$1(esm);
+		yield* fs.writeFileString(path.join(cwd, config.fileName), config.contents);
+	}
+	const plan = getScriptPlan$1(pkg.scripts);
+	for (const key of plan.skipped) yield* prompter.warn(`\`${key}\` script already exists in package.json - skipping`);
+	return {
+		...pkg,
+		scripts: plan.scripts
+	};
+}).pipe(Effect.withSpan("add-oxfmt.apply"));
+//#endregion
 //#region src/commands/add-oxlint/logic.ts
-function getMissingScripts(scripts) {
-	const missing = {};
-	if (!scripts["lint"]) missing["lint"] = "oxlint";
-	if (!scripts["lint:fix"]) missing["lint:fix"] = "oxlint --fix";
-	return missing;
+function getPackages(pkg, versions) {
+	return [getMismatchedPackage(pkg, "oxlint", versions.oxlint), getMismatchedPackage(pkg, "@chanom/dev-config", versions.devConfig)].filter((p) => p !== void 0);
+}
+function configFile(esm) {
+	return {
+		fileName: `oxlint.config.${esm ? "ts" : "mts"}`,
+		contents: `export { default } from '@chanom/dev-config/oxlint/config';\n`
+	};
+}
+function getScriptPlan(scripts) {
+	return planScripts(scripts, {
+		lint: "oxlint",
+		"lint:fix": "oxlint --fix"
+	});
 }
 //#endregion
 //#region src/commands/add-oxlint/index.ts
-function getPackages(pkg) {
-	return isPackageInstalled(pkg, "oxlint") ? [] : [`oxlint@1.71.0`, `@chanom/dev-config@0.0.3`];
+/** Returns a copy of `pkg` with missing scripts added; the caller owns writing package.json. */
+const apply = (cwd, esm, pkg) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const prompter = yield* Prompter;
+	const existing = yield* detectSetupFile("oxlint", cwd);
+	if (Option.isSome(existing)) yield* prompter.warn(`\`${path.basename(existing.value)}\` already exists - skipping oxlint config`);
+	else {
+		const config = configFile(esm);
+		yield* fs.writeFileString(path.join(cwd, config.fileName), config.contents);
+	}
+	const plan = getScriptPlan(pkg.scripts);
+	for (const key of plan.skipped) yield* prompter.warn(`\`${key}\` script already exists in package.json - skipping`);
+	return {
+		...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. */
+function planPackages(pkg, toppings, sweetness, versions) {
+	const packages = [];
+	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));
+	return [...new Set(packages)];
+}
+/** True when the .gitignore content already has the entry as its own line. */
+function hasGitignoreEntry(content, entry) {
+	const forms = /* @__PURE__ */ new Set([
+		entry,
+		`${entry}/`,
+		`/${entry}`,
+		`/${entry}/`
+	]);
+	return content.split(/\r?\n/).some((line) => forms.has(line.trim()));
+}
+/** .gitignore content with the entry appended, preserving existing lines and newline termination. */
+function appendGitignoreEntry(content, entry) {
+	if (content === "") return `${entry}\n`;
+	return content.endsWith("\n") ? `${content}${entry}\n` : `${content}\n${entry}\n`;
+}
+function selectedLinters(toppings) {
+	return toppings.filter((t) => t === "oxlint");
 }
-function apply(cwd, esm) {
-	const existing = detectSetupFile("oxlint", cwd);
-	if (existing) log.warn(`\`${basename(existing)}\` already exists - skipping oxlint config`);
-	else writeFileSync(join(cwd, `oxlint.config.${esm ? "ts" : "mts"}`), `export { default } from '@chanom/dev-config/oxlint/config';\n`);
-	const { pkg, pkgPath } = readPkg(cwd);
-	pkg.scripts ??= {};
-	const missing = getMissingScripts(pkg.scripts);
-	for (const [key, value] of Object.entries(missing)) pkg.scripts[key] = value;
-	const skipped = ["lint", "lint:fix"].filter((k) => !(k in missing));
-	for (const key of skipped) log.warn(`\`${key}\` script already exists in package.json - skipping`);
-	if (Object.keys(missing).length > 0) writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+function selectedFormatters(toppings) {
+	return toppings.filter((t) => t === "oxfmt");
 }
 //#endregion
 //#region src/commands/brew/index.ts
-async function brew(cwd = process.cwd()) {
-	intro(pc.magenta("🧋 Chanom - Let's brew your project!"));
-	if (!isGitRepo(cwd)) {
-		const s = spinner();
-		s.start("Git not found, initializing repository...");
-		init(cwd);
-		writeGitignore(cwd);
-		s.stop("Git initialized");
+const ensureGitRepo = (cwd) => Effect.gen(function* () {
+	const git = yield* Git;
+	if (yield* git.isRepo(cwd)) {
+		yield* Effect.logDebug("git repository already present");
+		return;
 	}
-	const pm = detectPm(cwd);
-	if (!existsSync(join(cwd, "package.json"))) {
-		log.error(`No package.json found. Run \`${pm} init\` first, then re-run \`chanom brew\`.`);
-		process.exit(1);
+	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 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)));
+	if (existing !== void 0 && hasGitignoreEntry(existing, "node_modules")) {
+		yield* Effect.logDebug("node_modules already present in .gitignore");
+		return;
 	}
-	const toppings = await 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"
-			}
-		],
-		required: false
-	});
-	if (typeof toppings === "symbol") process.exit(0);
-	const sweetness = await select({
-		message: "How sweet would you like it?",
-		options: [{
-			value: "light",
-			label: "light",
-			hint: "warn only, no blocking"
-		}, {
-			value: "medium",
-			label: "medium",
-			hint: "block on commit (husky + lint-staged + commitlint)"
-		}]
-	});
-	if (typeof sweetness === "symbol") process.exit(0);
-	const { pkg } = readPkg(cwd);
-	const esm = isEsm(pkg);
-	const packages = [];
-	if (toppings.includes("oxlint")) packages.push(...getPackages(pkg));
-	if (toppings.includes("oxfmt")) packages.push(...getPackages$1(pkg));
-	if (toppings.includes("knip")) packages.push(...getPackages$3(pkg));
-	if (sweetness === "medium") packages.push(...getPackages$4(pkg), ...getPackages$2(pkg), ...getPackages$5(pkg));
-	if (packages.length > 0) {
-		const s = spinner();
-		const uniquePackages = Array.from(new Set(packages));
-		s.start(`Installing ${uniquePackages.join(", ")}...`);
-		if (!installDev(pm, cwd, ...uniquePackages)) {
-			s.stop(pc.red("Package installation failed"));
-			log.error(`\`${pm} add -D\` failed. Fix the error above and re-run \`chanom brew\`.`);
-			process.exit(1);
-		}
-		s.stop("Packages installed");
+	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 prompter = yield* Prompter;
+	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"
+				}
+			],
+			required: false
+		}),
+		sweetness: yield* prompter.select({
+			message: "How sweet would you like it?",
+			options: [{
+				value: "light",
+				label: "light",
+				hint: "warn only, no blocking"
+			}, {
+				value: "medium",
+				label: "medium",
+				hint: "block on commit (husky + lint-staged + commitlint)"
+			}]
+		})
+	};
+}).pipe(Effect.withSpan("brew.askRecipe"));
+const installPackages = (pm, cwd, packages) => Effect.gen(function* () {
+	if (packages.length === 0) {
+		yield* Effect.logDebug("no packages to install");
+		return;
 	}
-	if (toppings.includes("oxlint")) apply(cwd, esm);
-	if (toppings.includes("oxfmt")) apply$1(cwd, esm);
-	if (toppings.includes("knip")) apply$3(cwd, esm);
-	if (sweetness === "medium") {
-		const huskyExisted = existsSync(join(cwd, ".husky"));
-		apply$4(cwd, pm);
-		apply$2(cwd, toppings.filter((t) => ["oxlint"].includes(t)), toppings.filter((t) => ["oxfmt"].includes(t)), !huskyExisted);
-		apply$5(cwd, pm);
+	const prompter = yield* Prompter;
+	const installer = yield* PackageInstaller;
+	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* () {
+	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 ?? {})) {
+		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* () {
+	if (sweetness !== "medium") return;
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const huskyExisted = yield* fs.exists(path.join(cwd, ".husky"));
+	yield* apply$4(cwd, pm);
+	yield* apply$2(cwd, selectedLinters(toppings), selectedFormatters(toppings), !huskyExisted);
+	yield* apply$5(cwd, pm);
+}).pipe(Effect.withSpan("brew.setupCommitGate"));
+const commitChanges = (cwd) => Effect.gen(function* () {
+	const git = yield* Git;
+	const prompter = yield* Prompter;
+	const s = yield* prompter.spinner("Committing changes...");
+	if (!(yield* git.hasIdentity(cwd))) yield* git.setLocalIdentity(cwd, "Chanom", "chanom@local");
+	yield* git.stageAll(cwd);
+	if (!(yield* git.hasStagedChanges(cwd))) {
+		yield* s.stop("Nothing to commit, skipping");
+		return;
 	}
-	const s2 = spinner();
-	s2.start("Committing changes...");
-	if (!hasIdentity(cwd)) setLocalIdentity(cwd, "Chanom", "chanom@local");
-	stageAll(cwd);
-	if (hasStagedChanges(cwd)) {
-		const result = commit(cwd, "chore: setup chanom configuration");
-		if (result.ok) s2.stop("Changes committed");
-		else {
-			s2.stop(pc.yellow("Could not commit changes automatically"));
-			const detail = result.stderr || result.stdout;
-			log.warn(`${detail ? detail + "\n" : ""}Your files are staged - commit them manually when ready.`);
-		}
-	} else s2.stop("Nothing to commit, skipping");
-	outro(pc.green(`Your Chanom with ${toppings.join(", ")} toppings and ${sweetness} sweetness is ready! Enjoy! 🧋`));
-}
+	const result = yield* git.commit(cwd, "chore: setup chanom configuration");
+	if (result.ok) {
+		yield* s.stop("Changes committed");
+		return;
+	}
+	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!"));
+	yield* ensureGitRepo(cwd);
+	yield* ensureGitIgnore(cwd);
+	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 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));
+	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! 🧋`));
+});
+//#endregion
+//#region src/cli.ts
+var UnknownCommand = class extends Data.TaggedError("UnknownCommand") {};
+const commands = { brew };
+const dispatch = (name, cwd) => Effect.gen(function* () {
+	if (name !== void 0 && Object.hasOwn(commands, name)) return yield* commands[name](cwd).pipe(Effect.withSpan(name));
+	return yield* new UnknownCommand({ command: name });
+});
+const reportError = (message) => Effect.gen(function* () {
+	yield* (yield* Prompter).error(message);
+	return 1;
+});
+const isCancellation = (cause) => Chunk.isEmpty(Cause.defects(cause)) && Chunk.every(Cause.failures(cause), (failure) => failure instanceof Cancelled);
+/** Prints the fully rendered cause, including the span trace of the failing step. */
+const traceFailure = (cause) => Effect.gen(function* () {
+	if (isCancellation(cause)) return;
+	yield* (yield* Prompter).debug(Cause.pretty(cause));
+});
+/** Runs the named command and returns the process exit code. */
+const run = (name, cwd = process.cwd(), options = {}) => {
+	const debug = options.debug ?? false;
+	return dispatch(name, cwd).pipe(Effect.as(0), debug ? Effect.tapErrorCause(traceFailure) : (effect) => effect, Effect.catchTags({
+		Cancelled: () => Effect.succeed(0),
+		UnknownCommand: (e) => reportError(`Unknown command: ${e.command ?? "(none)"}\nAvailable commands: ${Object.keys(commands).join(", ")}`),
+		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}).`)
+	}), Effect.catchAll((e) => reportError(`Unexpected error: ${e.message}`)), Logger.withMinimumLogLevel(debug ? LogLevel.Debug : LogLevel.Info));
+};
 //#endregion
 //#region src/index.ts
-const command = process.argv[2];
-if (command === "brew") await brew();
-else {
-	console.error(`Unknown command: ${command ?? "(none)"}`);
-	console.error("Usage: chanom brew");
-	process.exit(1);
-}
+const args = process.argv.slice(2);
+const debug = args.includes("--debug");
+const command = args.find((arg) => !arg.startsWith("--"));
+const ServicesLive = Layer.mergeAll(Prompter.Default, Git.Default, PackageInstaller.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(command, process.cwd(), { 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/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@chanom/cli",
-  "version": "0.0.3",
+  "version": "0.1.1",
   "description": "",
   "keywords": [],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/peeranat-dan/chanom.git",
+    "directory": "packages/cli"
+  },
   "bin": {
     "chanom": "./dist/index.js"
   },
@@ -12,18 +17,26 @@
   "type": "module",
   "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",
     "tsdown": "0.22.3",
     "typescript": "6.0.3",
+    "vitest": "3.2.6",
     "@chanom/dev-config": "0.0.3"
   },
   "scripts": {
     "build": "tsdown",
-    "dev": "tsdown --watch"
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
 }