@chanom/cli 0.2.2 → 0.4.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, agent coding standards, and commit hooks, picked with a couple of prompts.
 
 ## Install
 
@@ -38,6 +38,8 @@ 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
+   - `skills` - coding standards for AI agents (`.claude/skills`)
 2. **Sweetness** - how strict to be:
    - `light` - warn only, no blocking
    - `medium` - block on commit via husky + lint-staged + commitlint
@@ -60,16 +62,33 @@ 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                     |
+| `skills` | `.agents/skills/coding-standards/`, `.claude/skills/coding-standards` (symlink) | 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.
+
+The `skills` topping also installs no packages and adds no scripts. It writes
+the `coding-standards` agent skill - a router `SKILL.md` plus TypeScript, React,
+and Vitest references - into `.agents/skills/coding-standards/`, so any agent
+tool can read it, and links `.claude/skills/coding-standards` at that directory
+with a relative symlink rather than keeping a second copy. The standards target
+the stack chanom scaffolds (Vite + React + TypeScript, oxlint, oxfmt, vitest).
+
 `medium` sweetness additionally adds:
 
 - `husky` - installed via `husky init`
@@ -91,6 +110,14 @@ 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.
+- Skill files already on disk are warned about and skipped, and an existing
+  `.claude/skills/coding-standards` (a link of your own, or a real directory you
+  maintain by hand) is left alone - so re-running never overwrites standards you
+  have edited.
 
 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,120 @@ 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)) };
+	})
+} }) {};
+/** Every skill chanom can install, in install order. */
+const SKILLS = [{
+	name: "coding-standards",
+	files: [
+		{
+			"path": "references/react.md",
+			"contents": "# React\n\nReact 19 with the Vite plugin. Entry is `src/main.tsx`, which mounts `App` from\n`src/app.tsx` in `StrictMode`.\n\n## Structure\n\n`src/` grows by role as the app does: `components/`, `hooks/`, `utils/`,\n`pages/`, `providers/`. Feature-scoped code lives under `features/<name>/` and\nmirrors that same layout. Put code in the feature folder unless two features\nshare it.\n\n## Components\n\n- **Container / presentational**: containers fetch data and hold logic;\n  presentational components take props and return JSX with no side effects.\n- Props are wrapped in `Readonly<>`:\n  `export function UserCard({ name }: Readonly<UserCardProps>)`.\n- Conditional rendering uses a ternary (`isOpen ? <Panel /> : null`), never\n  `&&` — a falsy number renders as `0`.\n- Every component exports inline. `default` export is reserved for route-level\n  page components.\n- Shared state lives in a context provider under `providers/`. Reach for\n  context only once prop-passing spans three levels.\n\n## Hooks\n\nCustom hooks are named `use-<thing>.ts` and return an object, not a positional\ntuple, once they return more than two values. Every effect declares its full\ndependency array; an effect with no cleanup and no async work is usually a\nrender-time computation instead.\n"
+		},
+		{
+			"path": "references/typescript.md",
+			"contents": "# TypeScript\n\n## Types\n\n- Never use `any`. Reach for generics and utility types; when you must escape\n  the type system use `unknown` and narrow explicitly.\n- Type-only imports use `import type { ... }`. A mixed import splits its type\n  part into a separate `import type` line.\n- Derive types from their source rather than restating them — `z.infer` for a\n  schema, `ReturnType`/`Parameters` for a function, `typeof` for a const object.\n  A hand-written duplicate drifts.\n- Props and params objects are declared as `interface`, named after their owner:\n  `interface UserCardProps`, `interface UseCurrentUserParams`.\n\n## Modules\n\n- Functions, not classes. Hooks, utils, factories, and components are plain\n  exported functions.\n- Export inline (`export function formatDate(...)`) rather than a trailing\n  `export { ... }` block.\n- Import order is enforced by oxlint — run `pnpm lint --fix` rather than\n  hand-sorting.\n\n## Errors\n\nThrow `Error` (or a subclass) with a message naming what failed and the value\nthat caused it. An unused catch binding is omitted: `catch {`, not\n`catch (_e) {`.\n"
+		},
+		{
+			"path": "references/vitest.md",
+			"contents": "# Vitest\n\nTests run on jsdom with globals enabled — `describe`, `it`, `expect`, and `vi`\nneed no import. `src/test-setup.ts` loads `@testing-library/jest-dom/vitest`, so\nits matchers are available everywhere. Run with `pnpm test`, or `pnpm test:watch`\nwhile iterating.\n\n## Layout\n\nTests are colocated and named `*.test.ts` / `*.test.tsx`, sitting beside the\nfile they cover: `src/app.tsx` → `src/app.test.tsx`.\n\n## Component tests\n\nTesting Library with `user-event`, querying by role and accessible name:\n\n```tsx\ndescribe('UserCard', () => {\n  it('should render the user name correctly', () => {\n    render(<UserCard name=\"Ada\" />);\n    expect(screen.getByRole('heading', { name: 'Ada' })).toBeInTheDocument();\n  });\n\n  it('should call onSelect when clicked', async () => {\n    const user = userEvent.setup();\n    const onSelect = vi.fn();\n    render(<UserCard name=\"Ada\" onSelect={onSelect} />);\n    await user.click(screen.getByRole('button', { name: 'Select' }));\n    expect(onSelect).toHaveBeenCalledTimes(1);\n  });\n});\n```\n\n- Interactions go through `userEvent.setup()` and `await user.click(...)`, not\n  `fireEvent`.\n- Handlers are `vi.fn()` asserted by call count, including the negative case —\n  a disabled control asserts `toHaveBeenCalledTimes(0)`.\n- Query by `getByRole` / `getByText`. Reach for `getByTestId` only when no\n  accessible query exists, such as a decorative spinner.\n- Assert on what the user observes, not on state or implementation details.\n\n## Naming\n\nTest names read `should <behaviour> correctly` or `should <effect> when\n<action>`. Group a unit's tests in one `describe` named for the unit.\n"
+		},
+		{
+			"path": "SKILL.md",
+			"contents": "---\nname: coding-standards\ndescription: Coding standards for this Vite + React + TypeScript app. Use when writing or changing components, hooks, utils, or tests, and before committing.\n---\n\n# Coding standards\n\nVite + React 19 + TypeScript, scaffolded with `create-chanom-app`. oxlint lints,\noxfmt formats, vitest tests. Read the reference for what you touch **before**\nwriting, so new code matches the code already here.\n\n## Which reference to load\n\n| You are writing…                             | Load                       |\n| -------------------------------------------- | -------------------------- |\n| Any `.ts` / `.tsx` file                      | `references/typescript.md` |\n| A component, hook, or anything rendering JSX | `references/react.md`      |\n| A `*.test.ts` / `*.test.tsx` file            | `references/vitest.md`     |\n\nThese layer: a new component with a test reads all three. Load every row that\napplies.\n\n## Universal rules\n\n- Filenames are kebab-case: `user-card.tsx`, `use-current-user.ts`, `format-date.ts`.\n- Before adding a file, open two neighbouring files of the same kind and match\n  their shape — import order, export style, test naming.\n- Source lives under `src/`. Colocate a test beside the code it covers:\n  `src/utils/format-date.ts` → `src/utils/format-date.test.ts`.\n\n## Verify\n\nAfter implementing, from the project root:\n\n```sh\npnpm lint\npnpm test\npnpm build\n```\n\nDone only when all three exit clean. On failure, fix and rerun until they do.\nRun `pnpm format` before committing. Comment- or doc-only changes may skip all\nfour.\n\n## Committing\n\nAsk before committing. Use conventional commits under 100 characters:\n`<type>(<scope>): <subject>`, e.g. `feat(auth): add sign-out button`. Scope is\nthe area you touched, not the repo name.\n"
+		}
+	]
+}];
+/** Directory holding the real skill files, agent-agnostic. */
+const SKILLS_ROOT = ".agents/skills";
+/** Directory Claude Code reads skills from; its entries are links into {@link SKILLS_ROOT}. */
+const CLAUDE_SKILLS_ROOT = ".claude/skills";
+/** Files a skill writes, rooted at `.agents/skills/<name>/`. */
+function skillFiles(skill) {
+	return skill.files.map((file) => ({
+		path: `${SKILLS_ROOT}/${skill.name}/${file.path}`,
+		contents: file.contents
+	}));
+}
+/**
+* The `.claude/skills/<name>` link for a skill. Real files live under
+* `.agents/skills/` so any agent tool can read them; Claude Code only looks in
+* `.claude/skills/`, so it gets a link rather than a second copy.
+*/
+function skillLink(skill) {
+	return {
+		path: `${CLAUDE_SKILLS_ROOT}/${skill.name}`,
+		target: `../../${SKILLS_ROOT}/${skill.name}`
+	};
+}
+//#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 +324,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 +351,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 +455,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$7 = Effect.fn("add-commitlint.apply")(function* (cwd, pm) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -345,7 +477,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$6 = Effect.fn("add-husky.apply")(function* (cwd, pm) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const prompter = yield* Prompter;
@@ -401,7 +533,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$5 = 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 +570,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$4 = 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 +608,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$3 = 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 +649,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$2 = 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 +667,128 @@ const apply = Effect.fn("add-oxlint.apply")(function* (cwd, esm, pkg) {
 	};
 });
 //#endregion
+//#region src/commands/add-skills/logic.ts
+/**
+* Splits the skill's files by whether they are already on disk. Existing files
+* always win: a user who has edited the standards to fit their project keeps
+* those edits, so re-running `chanom brew` is safe.
+*/
+function planSkillFiles(files, exists) {
+	const write = [];
+	const skipped = [];
+	for (const file of files) if (exists(file.path)) skipped.push(file.path);
+	else write.push(file);
+	return {
+		write,
+		skipped
+	};
+}
+//#endregion
+//#region src/commands/add-skills/index.ts
+/**
+* Links `.claude/skills/<name>` at the real directory under `.agents/skills/`.
+* Anything already at the link path - a link the user already has, or a real
+* directory they maintain by hand - is left alone and reported.
+*/
+const linkSkill = Effect.fn("add-skills.linkSkill")(function* (cwd, link) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const prompter = yield* Prompter;
+	const linkPath = path.join(cwd, link.path);
+	if (yield* fs.exists(linkPath)) {
+		yield* prompter.warn(`\`${link.path}\` already exists - skipping link`);
+		return;
+	}
+	yield* fs.makeDirectory(path.dirname(linkPath), { recursive: true });
+	yield* fs.symlink(link.target, linkPath);
+});
+/**
+* Writes every chanom skill into `.agents/skills/`, then links it into
+* `.claude/skills/`. Files already on disk are left untouched, so re-running is
+* safe. Contributes no packages and no scripts, so - like `add-vscode` - it
+* returns nothing for the caller to persist.
+*/
+const apply$1 = Effect.fn("add-skills.apply")(function* (cwd) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const prompter = yield* Prompter;
+	const files = SKILLS.flatMap(skillFiles);
+	const present = /* @__PURE__ */ new Set();
+	for (const file of files) if (yield* fs.exists(path.join(cwd, file.path))) present.add(file.path);
+	const plan = planSkillFiles(files, (filePath) => present.has(filePath));
+	for (const skipped of plan.skipped) yield* prompter.warn(`\`${skipped}\` already exists - skipping`);
+	for (const file of plan.write) {
+		const dest = path.join(cwd, file.path);
+		yield* fs.makeDirectory(path.dirname(dest), { recursive: true });
+		yield* fs.writeFileString(dest, file.contents);
+	}
+	for (const skill of SKILLS) yield* linkSkill(cwd, skillLink(skill));
+});
+//#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 +803,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 +882,16 @@ const askRecipe = Effect.fn("brew.askRecipe")(function* () {
 					value: "knip",
 					label: "knip",
 					hint: "dead code remover"
+				},
+				{
+					value: "vscode",
+					label: "vscode",
+					hint: "editor settings + extension recommendations"
+				},
+				{
+					value: "skills",
+					label: "skills",
+					hint: "coding standards for AI agents (.claude/skills)"
 				}
 			],
 			required: false
@@ -650,9 +923,11 @@ 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$2(cwd, esm, updated);
+	if (toppings.includes("oxfmt")) updated = yield* apply$3(cwd, esm, updated);
+	if (toppings.includes("knip")) updated = yield* apply$5(cwd, esm, updated);
+	if (toppings.includes("vscode")) yield* apply(cwd, oxfmtConfigPath(esm));
+	if (toppings.includes("skills")) yield* apply$1(cwd);
 	return updated;
 });
 const persistScripts = Effect.fn("brew.persistScripts")(function* (pkgPath, pkg, updated) {
@@ -684,14 +959,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$6(cwd, pm);
+	if (wantsLintStaged(toppings)) yield* apply$4(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$7(cwd, pm);
 });
 const commitChanges = Effect.fn("brew.commitChanges")(function* (cwd) {
 	const git = yield* Git;
@@ -750,10 +1025,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 +1045,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.4.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",