@chanom/cli 0.2.2 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @chanom/cli
 
-Interactive CLI that brews dev tooling config into your project - oxlint, oxfmt, knip, 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, and commit hooks, picked with a couple of prompts.
 
 ## Install
 
@@ -38,6 +38,7 @@ Debug mode logs each step (detected package manager, planned packages, every com
    - `oxlint` - fast Rust-based linter
    - `oxfmt` - fast Rust-based formatter
    - `knip` - dead code remover
+   - `vscode` - editor settings + extension recommendations
 2. **Sweetness** - how strict to be:
    - `light` - warn only, no blocking
    - `medium` - block on commit via husky + lint-staged + commitlint
@@ -60,16 +61,25 @@ 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`                   |
+| 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                     |
 
 \* `.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).
 
+The `vscode` topping installs no packages and adds no scripts. It writes editor
+settings that route formatting and lint fixes through the
+[oxc extension](https://marketplace.visualstudio.com/items?itemName=oxc.oxc-vscode)
+on save (`editor.formatOnSave` stays off so both run in one pass), points
+`oxc.fmt.configPath` at the oxfmt config, and recommends the extension so
+teammates are prompted to install it. Only portable settings are written - no
+`cSpell.words` or other repo-specific entries.
+
 `medium` sweetness additionally adds:
 
 - `husky` - installed via `husky init`
@@ -91,6 +101,10 @@ 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.
+- `.vscode/settings.json` and `.vscode/extensions.json` are merged, not replaced: a
+  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.
 
 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.
 

package/dist/index.js

@@ -1,42 +1,122 @@
 #!/usr/bin/env node
-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 { Cause, Chunk, Data, Effect, Layer, LogLevel, Logger, Option, Stream } from "effect";
 import * as clack from "@clack/prompts";
-//#region src/bundled-versions.ts
-const bundledVersions = {
-	oxlint: "1.73.0",
-	oxlintTsgolint: "0.24.0",
-	oxfmt: "0.58.0",
-	knip: "6.26.0",
-	devConfig: "0.0.3"
+import pc from "picocolors";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+//#region ../internal/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"]
 };
-//#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";
+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);
 }
-function isPackageInstalled(pkg, name) {
-	return name in (pkg.dependencies ?? {}) || name in (pkg.devDependencies ?? {});
+/** 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 stripRangePrefix(version) {
-	return version.replace(/^[\^~]/, "");
+/** 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";
 }
-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 ../internal/src/domain/vscode.ts
+/** Keys VS Code reads as a per-language override, e.g. `[typescript]`. */
+const LANGUAGES = [
+	"markdown",
+	"json",
+	"typescriptreact",
+	"typescript",
+	"javascript"
+];
+const OXC_FORMATTER = "oxc.oxc-vscode";
+/** The extensions a chanom project recommends; unioned into an existing list. */
+const RECOMMENDED_EXTENSIONS = [OXC_FORMATTER];
+/**
+* The VS Code settings chanom contributes. Every value is portable across
+* projects - repo-specific entries (`cSpell.words`, `git.*`) are deliberately
+* excluded so this can be dropped into any project without carrying chanom's
+* own choices.
+*
+* `editor.formatOnSave` is false on purpose: formatting runs through the oxc
+* code action instead, so formatting and lint fixes apply in one pass rather
+* than racing each other.
+*/
+function chanomSettings(oxfmtConfigPath) {
+	return {
+		"editor.defaultFormatter": OXC_FORMATTER,
+		"editor.formatOnSave": false,
+		"editor.codeActionsOnSave": {
+			"source.format.oxc": "always",
+			"source.fixAll.oxc": "always",
+			"source.removeUnusedImports": "always"
+		},
+		"oxc.fmt.configPath": oxfmtConfigPath,
+		"oxc.typeAware": true,
+		...Object.fromEntries(LANGUAGES.map((language) => [`[${language}]`, { "editor.defaultFormatter": OXC_FORMATTER }]))
+	};
+}
+/**
+* Merges `wanted` settings into `current` without overwriting anything already
+* set, mirroring `planScripts`. The merge is one level deep by key: a key the
+* user already has is left untouched even when its value is an object, because
+* a partially merged `editor.codeActionsOnSave` is more surprising than one the
+* user fully owns.
+*/
+function planSettings(current, wanted) {
+	const settings = { ...current };
+	const added = [];
+	const skipped = [];
+	for (const [key, value] of Object.entries(wanted)) if (Object.hasOwn(settings, key)) skipped.push(key);
+	else {
+		settings[key] = value;
+		added.push(key);
+	}
+	return {
+		settings,
+		added,
+		skipped
+	};
+}
+/** Unions `wanted` into the existing recommendations, preserving existing order. */
+function planExtensions(current, wanted) {
+	const recommendations = [...current ?? []];
+	const added = [];
+	for (const extension of wanted) if (!recommendations.includes(extension)) {
+		recommendations.push(extension);
+		added.push(extension);
+	}
+	return {
+		recommendations,
+		added
+	};
 }
 //#endregion
-//#region src/services/command-runner.ts
+//#region ../internal/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* () {
+var CommandRunner = class extends Effect.Service()("internal/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}`)));
@@ -67,9 +147,9 @@ var CommandRunner = class extends Effect.Service()("cli/CommandRunner", { effect
 	};
 }) }) {};
 //#endregion
-//#region src/services/git.ts
+//#region ../internal/src/services/git.ts
 /** Git operations, built on top of {@link CommandRunner}. */
-var Git = class extends Effect.Service()("cli/Git", { effect: Effect.gen(function* () {
+var Git = class extends Effect.Service()("internal/Git", { effect: Effect.gen(function* () {
 	const runner = yield* CommandRunner;
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -117,35 +197,76 @@ var Git = class extends Effect.Service()("cli/Git", { effect: Effect.gen(functio
 	};
 }) }) {};
 //#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"]
+//#region ../internal/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()("internal/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)),
+	info: (message) => Effect.sync(() => clack.log.info(message)),
+	/** Prints a message with no icon or styling (help text, plan summaries). */
+	message: (message) => Effect.sync(() => clack.log.message(message)),
+	debug: (message) => Effect.sync(() => clack.log.message(pc.dim(message))),
+	text: (params) => guardCancel(() => clack.text({
+		message: params.message,
+		placeholder: params.placeholder,
+		defaultValue: params.defaultValue,
+		initialValue: params.initialValue,
+		validate: params.validate
+	})),
+	confirm: (params) => guardCancel(() => clack.confirm({
+		message: params.message,
+		initialValue: params.initialValue ?? true
+	})),
+	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/bundled-versions.ts
+const bundledVersions = {
+	oxlint: "1.73.0",
+	oxlintTsgolint: "0.24.0",
+	oxfmt: "0.58.0",
+	knip: "6.26.0",
+	devConfig: "0.0.3"
 };
-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);
+//#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";
 }
-/** 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 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/domain/package-manager.ts
 /**
 * 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
@@ -159,10 +280,6 @@ function workspaceRootFlags(pm, hints) {
 		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") {};
@@ -190,35 +307,6 @@ var PackageInstaller = class extends Effect.Service()("cli/PackageInstaller", {
 	], cwd)), 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/utils/detect-pm.ts
 const detectPm = (cwd, userAgent = process.env["npm_config_user_agent"], fallback = "pnpm") => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
@@ -323,7 +411,7 @@ function commitMsgHook(pm) {
 }
 //#endregion
 //#region src/commands/add-commitlint/index.ts
-const apply$5 = Effect.fn("add-commitlint.apply")(function* (cwd, pm) {
+const apply$6 = Effect.fn("add-commitlint.apply")(function* (cwd, pm) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -345,7 +433,7 @@ function getPackages$4(pkg) {
 //#endregion
 //#region src/commands/add-husky/index.ts
 var HuskyInitFailed = class extends Data.TaggedError("HuskyInitFailed") {};
-const apply$4 = Effect.fn("add-husky.apply")(function* (cwd, pm) {
+const apply$5 = Effect.fn("add-husky.apply")(function* (cwd, pm) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -401,7 +489,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 = Effect.fn("add-knip.apply")(function* (cwd, esm, pkg) {
+const apply$4 = Effect.fn("add-knip.apply")(function* (cwd, esm, pkg) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -438,7 +526,7 @@ 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) {
+const apply$3 = 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;
@@ -476,7 +564,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 = Effect.fn("add-oxfmt.apply")(function* (cwd, esm, pkg) {
+const apply$2 = Effect.fn("add-oxfmt.apply")(function* (cwd, esm, pkg) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -517,7 +605,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 = Effect.fn("add-oxlint.apply")(function* (cwd, esm, pkg) {
+const apply$1 = Effect.fn("add-oxlint.apply")(function* (cwd, esm, pkg) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -535,6 +623,70 @@ const apply = Effect.fn("add-oxlint.apply")(function* (cwd, esm, pkg) {
 	};
 });
 //#endregion
+//#region src/commands/add-vscode/index.ts
+const writeJson = Effect.fn("add-vscode.writeJson")(function* (filePath, value) {
+	yield* (yield* FileSystem.FileSystem).writeFileString(filePath, JSON.stringify(value, null, 2) + "\n");
+});
+/**
+* Reads and parses an existing `.vscode` file. `.vscode` files are JSONC by
+* convention, so a file we cannot parse is not an error - it is a file the user
+* hand-wrote with comments. Returns `None` for both "absent" and "unparseable";
+* the caller distinguishes them via `fs.exists` to warn appropriately.
+*/
+const readJson = Effect.fn("add-vscode.readJson")(function* (filePath) {
+	const fs = yield* FileSystem.FileSystem;
+	if (!(yield* fs.exists(filePath))) return Option.none();
+	const contents = yield* fs.readFileString(filePath);
+	return yield* Effect.try(() => JSON.parse(contents)).pipe(Effect.map(Option.some), Effect.orElseSucceed(() => Option.none()));
+});
+const applySettings = Effect.fn("add-vscode.applySettings")(function* (vscodeDir, oxfmtConfigPath) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const prompter = yield* Prompter;
+	const filePath = path.join(vscodeDir, "settings.json");
+	const existed = yield* fs.exists(filePath);
+	const existing = yield* readJson(filePath);
+	if (existed && Option.isNone(existing)) {
+		yield* prompter.warn("`.vscode/settings.json` could not be parsed (comments?) - skipping settings");
+		return;
+	}
+	const plan = planSettings(Option.getOrUndefined(existing), chanomSettings(oxfmtConfigPath));
+	for (const key of plan.skipped) yield* prompter.warn(`\`${key}\` is already set in .vscode/settings.json - skipping`);
+	if (plan.added.length > 0) yield* writeJson(filePath, plan.settings);
+});
+const applyExtensions = Effect.fn("add-vscode.applyExtensions")(function* (vscodeDir) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const prompter = yield* Prompter;
+	const filePath = path.join(vscodeDir, "extensions.json");
+	const existed = yield* fs.exists(filePath);
+	const existing = yield* readJson(filePath);
+	if (existed && Option.isNone(existing)) {
+		yield* prompter.warn("`.vscode/extensions.json` could not be parsed (comments?) - skipping recommendations");
+		return;
+	}
+	const plan = planExtensions(Option.getOrUndefined(existing)?.recommendations, RECOMMENDED_EXTENSIONS);
+	if (plan.added.length > 0) yield* writeJson(filePath, {
+		...Option.getOrUndefined(existing),
+		recommendations: plan.recommendations
+	});
+});
+/**
+* Writes `.vscode/settings.json` and `.vscode/extensions.json`, merging into
+* whatever is already there. Existing settings keys and recommendations always
+* win, so re-running is safe and never clobbers the user's editor config.
+*
+* Unlike the other add-* commands this contributes no packages and no scripts,
+* so it returns nothing - there is no `Pkg` for the caller to persist.
+*/
+const apply = Effect.fn("add-vscode.apply")(function* (cwd, oxfmtConfigPath) {
+	const fs = yield* FileSystem.FileSystem;
+	const vscodeDir = (yield* Path.Path).join(cwd, ".vscode");
+	yield* fs.makeDirectory(vscodeDir, { recursive: true });
+	yield* applySettings(vscodeDir, oxfmtConfigPath);
+	yield* applyExtensions(vscodeDir);
+});
+//#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) {
@@ -549,6 +701,15 @@ function planPackages(pkg, toppings, sweetness, versions) {
 	}
 	return [...new Set(packages)];
 }
+/**
+* Path the VS Code oxc extension should read the oxfmt config from. Mirrors the
+* name `add-oxfmt` writes, so the setting points at a real file whenever oxfmt
+* is a selected topping; without oxfmt the default name is still the sensible
+* value for a config the user may add later.
+*/
+function oxfmtConfigPath(esm) {
+	return `oxfmt.config.${esm ? "ts" : "mts"}`;
+}
 /** True when at least one topping gives lint-staged something to run. */
 function wantsLintStaged(toppings) {
 	return selectedLinters(toppings).length > 0 || selectedFormatters(toppings).length > 0;
@@ -619,6 +780,11 @@ const askRecipe = Effect.fn("brew.askRecipe")(function* () {
 					value: "knip",
 					label: "knip",
 					hint: "dead code remover"
+				},
+				{
+					value: "vscode",
+					label: "vscode",
+					hint: "editor settings + extension recommendations"
 				}
 			],
 			required: false
@@ -650,9 +816,10 @@ const installPackages = Effect.fn("brew.installPackages")(function* (pm, cwd, pa
 });
 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);
+	if (toppings.includes("oxlint")) updated = yield* apply$1(cwd, esm, updated);
+	if (toppings.includes("oxfmt")) updated = yield* apply$2(cwd, esm, updated);
+	if (toppings.includes("knip")) updated = yield* apply$4(cwd, esm, updated);
+	if (toppings.includes("vscode")) yield* apply(cwd, oxfmtConfigPath(esm));
 	return updated;
 });
 const persistScripts = Effect.fn("brew.persistScripts")(function* (pkgPath, pkg, updated) {
@@ -684,14 +851,14 @@ const setupCommitGate = Effect.fn("brew.setupCommitGate")(function* (cwd, pm, to
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
 	const huskyExisted = yield* fs.exists(path.join(cwd, ".husky"));
-	yield* apply$4(cwd, pm);
-	if (wantsLintStaged(toppings)) yield* apply$2(cwd, selectedLinters(toppings), selectedFormatters(toppings), !huskyExisted);
+	yield* apply$5(cwd, pm);
+	if (wantsLintStaged(toppings)) yield* apply$3(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);
+	yield* apply$6(cwd, pm);
 });
 const commitChanges = Effect.fn("brew.commitChanges")(function* (cwd) {
 	const git = yield* Git;
@@ -750,10 +917,19 @@ const traceFailure = (cause) => Effect.gen(function* () {
 	if (isCancellation(cause)) return;
 	yield* (yield* Prompter).debug(Cause.pretty(cause));
 });
+/**
+* Pins the error channel to `never` at this boundary. If `catchTags` above ever
+* stops handling an error tag, that tag leaks into `E` and this call fails to
+* compile — forcing every command error to be handled here.
+*/
+const allErrorsHandled = (effect) => effect;
 /** 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({
+	return allErrorsHandled(dispatch(name, cwd).pipe(Effect.as(0), debug ? Effect.tapErrorCause(traceFailure) : (effect) => effect, Effect.catchTags({
+		BadArgument: (e) => reportError(`Unexpected error: ${e.message}`),
+		SystemError: (e) => reportError(`Unexpected error: ${e.message}`)
+	}), 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.`),
@@ -761,7 +937,7 @@ const run = (name, cwd = process.cwd(), options = {}) => {
 		InstallFailed: (e) => reportError(`Package installation with ${e.pm} failed.`),
 		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));
+	}))).pipe(Logger.withMinimumLogLevel(debug ? LogLevel.Debug : LogLevel.Info));
 };
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chanom/cli",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "",
   "keywords": [],
   "repository": {
@@ -32,7 +32,8 @@
     "tsdown": "0.22.3",
     "typescript": "6.0.3",
     "vitest": "3.2.6",
-    "@chanom/dev-config": "0.0.3"
+    "@chanom/dev-config": "0.0.3",
+    "@chanom/internal": "0.0.0"
   },
   "scripts": {
     "build": "tsdown",