@bonesofspring/ai-rules 0.2.2 → 0.2.4

package/CHANGELOG.md

@@ -0,0 +1,65 @@
+# Changelog
+
+## Unreleased
+
+### Breaking
+
+- **Deprecated rule stubs removed** (Cursor + Claude `next`): `types-public-imports`, `api-public-imports`, `no-cross-component-styles-import` / `component-styles`. Use `public-imports` and `react-ui` instead.
+- **`next` preset — post-change-lint no longer always-on:** Cursor `post-change-lint.mdc` and Claude twin are **requestable** (not session-start / `alwaysApply`). Load explicitly after code edits via skill `feature-delivery` or agent `build-verifier`. Session-start / alwaysApply is now **3** rules: `next-app-core`, `package-manager`, `code-quality-and-refactoring`. Workspace dogfood `.cursor/rules/post-change-lint.mdc` synced.
+
+### Added
+
+- **MCP configs in presets** (`next` + `ios-swift`, Cursor + Claude): `mcp.json` + `MCP.md`. Cursor → `.cursor/mcp.json`; Claude → project-root `.mcp.json`. **next:** Context7, Playwright, Chrome DevTools, Figma (remote). **ios-swift:** Context7 + Figma. CLI `init`/`clean` manage these paths.
+- **Cursor + Claude `ios-swift` — full agent-team parity with `next`:** **21** agents (Playwright trio → `xcuitest-test-{planner,generator,healer}`), **7** skills (`xcuitest-e2e`), **5** slash commands, `hooks.json` + iOS-adapted `chain-team-phases.sh` (Cursor) / hook scripts + README (Claude), `team/fixtures/` ×3, `AGENTS.md` (Cursor) / thin `CLAUDE.md` (≤35 lines).
+- **ios-swift rules:** agent-team intake/orchestrator, `xcode-tooling`, `reference-features`, domain rules (`navigation-coordinators`, `persistence-data`, `security-ios`, `module-public-api`), `technical-retro` alias; **21** rule topics (+ README). CLI init copies agents, hooks, skills, team, `AGENTS.md`.
+- **ios-swift retro follow-ups:** `build-verifier` preset checks (chain ≠ next; ban Playwright/`lint:js` handoffs); enriched 16 priority agent prompts + 6 skills; dogfood checklist (5 scenarios) in `AGENTS.md` / `reference-features`; Cursor-only **`BUGBOT.md`** (iOS review priorities).
+
+### Changed
+
+- **Agent team slug bootstrap:** `/task` and `/feature-start` (Cursor + Claude, `next` + `ios-swift`) create `.cursor|claude/team/tasks/<slug>/` via **Write**, not Shell `mkdir` — avoids Cursor sandbox `Operation not permitted` (esp. macOS Desktop/Documents). Orchestrator + `team/README` + `task-router` document the rule.
+- **Token model (ios-swift + next):** both presets use **3** alwaysApply / session-start rules (~77 / ~59 body lines). Post-change verification is **requestable** — ios: `post-change-build`; next: `post-change-lint`. Orchestrator, intake, code-review, feature-delivery, tooling rules load on-demand (`paths:` / description).
+- Claude `next`: `agent-team-orchestrator` and `code-review-mr` use `paths:` (on-demand) — session-start matches the 3-rule budget above.
+- Cursor `next` agents: all pipeline agents set **`readonly: false`** so they can write `.cursor/team/**`. Production/app restrictions remain in prompt bodies (Cursor `readonly: true` blocks all file writes, including team artifacts).
+- **ios-swift:** `networking-services` HTTP-only (persistence split out); soft AC-19 for thin aliases (`agent-team-intake`, `technical-retro`); `feature-developer` requires stack-specific hook handoff forks.
+
+### Notes
+
+- **P2 optional (ios-swift):** Remaining polish: feature-delivery matrix enrichment, swift-conventions body cap. (`BUGBOT.md` shipped.)
+
+## 0.2.2
+
+### Breaking
+
+- **`clean` is selective:** removes only CLI-managed paths (`rules`, `commands`, optional `agents`/`hooks`/`skills`/`team`, plus Cursor `hooks.json` / `BUGBOT.md` / `AGENTS.md`, Claude `CLAUDE.md`). Does **not** wipe the entire `.cursor/` or `.claude/` directory.
+
+### Added
+
+- Cursor `next`: `architecture-boundaries-ui.mdc`, `navigation-router-ui.mdc` (slim UI-edit rules); Claude equivalents under `architecture/` and `stack/`.
+- Cursor/Claude `next`: `AGENTS.md` on Cursor init; team `fixtures/` for pipeline profiles; pipeline profiles (`full` / `standard` / `light`) in `task-router`.
+- Claude `next`: `hooks/chain-team-phases.sh` feature parity with Cursor (tool paths only differ).
+
+### Changed
+
+- Narrower globs for full `architecture-boundaries` / `navigation-router(-stack)` vs UI slim rules; `layer-barrel-exports` → `index.ts`; styles colocation consolidated into `react-ui` (stubs remain).
+- README documents `AGENTS.md` and selective `clean`.
+
+## 0.2.0
+
+### Breaking
+
+- **Import rules merged:** `types-public-imports.mdc` and `api-public-imports.mdc` → **`public-imports.mdc`** (Claude: `architecture/public-imports.md`). Old filenames remain as deprecated stubs for one release cycle.
+- **`feature-delivery-flow.mdc` removed** — content merged into `feature-delivery-workflow.mdc`.
+- **`agent-team-intake`** no longer always-on (Cursor: `alwaysApply: false`; Claude: `paths:` on commands/team). Use orchestrator or `/task`.
+
+### Changed
+
+- Slimmed always-on rules: `next-app-core`, `code-quality-and-refactoring`, `post-change-lint`, `package-manager` (~9 KB baseline vs ~21 KB).
+- Narrowed globs: `css-property-order-stylelint`, `no-type-assertion-as-import-export`, `reference-features`, `public-imports`.
+- `css-property-order` stub — property list delegated to Stylelint `--fix`.
+- Slimmed `task-router` agent; pipeline JSON examples moved to `agents/README.md`.
+- Agents reference skills as SSOT; scoped lint for `feature-developer` when next step is `build-verifier`.
+- Orchestrator: explicit fast-path when to skip pipeline.
+
+## 0.1.42
+
+Prior releases — see git history.

package/README.md

@@ -1,6 +1,6 @@
 # @bonesofspring/ai-rules
 
-Presets for Cursor and Claude Code: rules, commands, plus for Claude `CLAUDE.md` and `skills` / `agents` / `hooks` when the preset includes them. Install from npm into a project so you don’t have to copy files out of the repo by hand.
+Presets for Cursor and Claude Code: rules, commands, plus optional `agents`, `hooks`, `skills`, team artifacts, and MCP configs when the preset includes them. For Claude: `CLAUDE.md`. Install from npm into a project so you don’t have to copy files out of the repo by hand.
 
 Node 18+.
 
@@ -13,9 +13,27 @@ npx @bonesofspring/ai-rules clean cursor
 
 Global: `npm i -g @bonesofspring/ai-rules`, then `ai-rules ...`.
 
-`init` merges into the current directory: dirs are created, matching files are **overwritten**. `--preset` and the subcommand can be in either order, e.g. `--preset=next init cursor`.
+`init` merges into the **current working directory** (or `--cwd <dir>`): dirs are created, matching files are **overwritten**. `--preset` defaults to **`next`**. Supported forms:
 
-`clean cursor` / `clean claude` removes what this CLI installs: for Cursor, the entire `.cursor` directory; for Claude, `.claude/rules`, `.claude/commands`, `skills`, `agents`, `hooks`, and `CLAUDE.md` when present. Anything else under `.claude` is left alone.
+```bash
+npx @bonesofspring/ai-rules init cursor --preset next
+npx @bonesofspring/ai-rules init cursor next
+npx @bonesofspring/ai-rules init cursor          # preset next by default
+npx @bonesofspring/ai-rules cursor init --preset next
+```
+
+If `.cursor` does not appear, check the command output for errors and confirm you run init from the **target project root** (where the app lives), not from `node_modules`. Success ends with: `Done. .cursor installed at <absolute-path>`.
+
+### `clean` (breaking vs older wipe behavior)
+
+`clean cursor` / `clean claude` removes **only CLI-managed paths** — not the entire `.cursor/` or `.claude/` tree:
+
+- `rules/`, `commands/`
+- optional dirs when present: `agents/`, `hooks/`, `skills/`, `team/`
+- Cursor root files: `hooks.json`, `BUGBOT.md`, `AGENTS.md`, `MCP.md`, `mcp.json`
+- Claude: `CLAUDE.md`, `MCP.md` under `.claude/`; project `.mcp.json` at repo root
+
+Any other files you added under `.cursor/` or `.claude/` (notes, local overrides, IDE state) are **left intact**. Older releases that deleted the whole tool directory are no longer the behavior.
 
 Where things go on `init`:
 
@@ -23,7 +41,12 @@ Where things go on `init`:
 |---|--------|--------|
 | rules | `.cursor/rules` | `.claude/rules` |
 | commands | `.cursor/commands` | `.claude/commands` |
-| other | — | root `CLAUDE.md` → `.claude/CLAUDE.md`; folders `skills`, `agents`, `hooks` → under `.claude/` with the same names |
+| agents | `.cursor/agents` | `.claude/agents` |
+| hooks | `.cursor/hooks`, `.cursor/hooks.json` | `.claude/hooks` |
+| skills | `.cursor/skills` | `.claude/skills` |
+| team artifacts template | `.cursor/team` | `.claude/team` |
+| MCP | `mcp.json` → `.cursor/mcp.json`, `MCP.md` → `.cursor/` | `mcp.json` → **`.mcp.json`** (project root), `MCP.md` → `.claude/` |
+| other | `BUGBOT.md`, `AGENTS.md` → `.cursor/` | `CLAUDE.md` → `.claude/CLAUDE.md` |
 
 The package ships presets including **`next`** (Next.js stack) and **`ios-swift`** (iOS apps on Swift / SwiftUI). Other preset names: see `presets/` in the [repo](https://github.com/bonesofspring/ai-rules). Name is a single path segment, no `/` or `..`.
 

package/bin/cli.js

@@ -5,51 +5,95 @@
 const fs = require('fs');
 const path = require('path');
 
-const packageRoot = path.join(__dirname, '..');
-
 /** Single path segment: letters, digits, dot, underscore, hyphen; no separators or "..". */
 const PRESET_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+const DEFAULT_PRESET = 'next';
+const TOOLS = new Set(['cursor', 'claude']);
 
 const PRESETS = {
   cursor: {
     rulesDir: '.cursor/rules',
     commandsDir: '.cursor/commands',
     relBase: ['presets', 'cursor'],
+    optionalCursorDirs: ['agents', 'hooks', 'skills', 'team'],
+    hooksJsonSrc: 'hooks.json',
+    /** Project MCP → `.cursor/mcp.json` */
+    mcpJsonSrc: 'mcp.json',
+    mcpJsonDest: '.cursor/mcp.json',
+    toolRootFiles: ['BUGBOT.md', 'AGENTS.md', 'MCP.md'],
   },
   claude: {
     rulesDir: '.claude/rules',
     commandsDir: '.claude/commands',
     relBase: ['presets', 'claude'],
-    /** Optional dirs under preset root → under `.claude/` (recursive copy). */
-    optionalClaudeDirs: ['skills', 'agents', 'hooks'],
-    /** Copied from preset root to `.claude/CLAUDE.md` when present. */
+    optionalClaudeDirs: ['skills', 'agents', 'hooks', 'team'],
     claudeMdSrc: 'CLAUDE.md',
+    /** Project MCP lives at repo root (Claude Code project scope), not under `.claude/`. */
+    mcpJsonSrc: 'mcp.json',
+    mcpJsonDest: '.mcp.json',
+    toolRootFiles: ['MCP.md'],
   },
 };
 
+function getPackageRoot() {
+  try {
+    return path.dirname(require.resolve('@bonesofspring/ai-rules/package.json'));
+  } catch {
+    return path.join(__dirname, '..');
+  }
+}
+
 function printHelp() {
   console.log(`@bonesofspring/ai-rules
 
 Usage:
-  ai-rules init <cursor|claude> --preset <name>   Copy preset rules and commands into the current directory
-  ai-rules clean <cursor|claude>                 Remove preset target rules and commands directories
+  ai-rules init <cursor|claude> [--preset <name>]
+  ai-rules init <cursor|claude> <preset-name>
+  ai-rules clean <cursor|claude> [--cwd <dir>]
+
+Options:
+  --preset <name>   Preset name (default: ${DEFAULT_PRESET})
+  --cwd <dir>       Target project directory (default: current working directory)
 
 Notes:
-  init merges into existing target folders; same-named files are overwritten.
-  clean cursor removes the entire .cursor directory (if present).
-  Flags may appear before or after the subcommand (e.g. --preset next init cursor).
+  init merges into the target directory; same-named files are overwritten.
+  Cursor init copies rules, commands, agents, hooks, skills, team, hooks.json, BUGBOT.md, AGENTS.md, MCP.md, mcp.json → .cursor/mcp.json.
+  Claude init copies rules, commands, skills, agents, hooks, team, CLAUDE.md, MCP.md, and mcp.json → .mcp.json (project root).
+  Command forms: "init cursor --preset next", "init cursor next", "--preset next init cursor", "cursor init --preset next".
 
 Examples:
   npx @bonesofspring/ai-rules init cursor --preset next
+  npx @bonesofspring/ai-rules init cursor next
+  npx @bonesofspring/ai-rules init cursor --preset ios-swift
+  npx @bonesofspring/ai-rules init claude
   npx @bonesofspring/ai-rules init claude --preset ios-swift
-  npx @bonesofspring/ai-rules clean claude
+  npx @bonesofspring/ai-rules clean cursor
 `);
 }
 
 function parseArgs(argv) {
-  const args = { _: [] };
+  const args = { _: [], cwd: undefined, preset: undefined, presetError: undefined };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
+    if (a === '--cwd') {
+      const value = argv[i + 1];
+      if (value === undefined || value.startsWith('-')) {
+        args.cwdError = 'Missing value for --cwd';
+        continue;
+      }
+      args.cwd = value;
+      i++;
+      continue;
+    }
+    if (a.startsWith('--cwd=')) {
+      const value = a.slice('--cwd='.length);
+      if (value === '') {
+        args.cwdError = 'Missing value after --cwd=';
+        continue;
+      }
+      args.cwd = value;
+      continue;
+    }
     if (a === '--preset') {
       const value = argv[i + 1];
       if (value === undefined || value.startsWith('-')) {
@@ -70,17 +114,53 @@ function parseArgs(argv) {
       args.preset = value;
       continue;
     }
+    if (a === '-h' || a === '--help') {
+      args.help = true;
+      continue;
+    }
     args._.push(a);
   }
   return args;
 }
 
+/**
+ * Supports: init cursor, cursor init, init cursor next (positional preset).
+ */
+function normalizeInitClean(parsed) {
+  const positional = [...parsed._];
+  let command;
+  let tool;
+  let presetFromPositional;
+
+  if (positional.length >= 2 && TOOLS.has(positional[0]) && positional[1] === 'init') {
+    command = 'init';
+    tool = positional[0];
+    presetFromPositional = positional[2];
+  } else if (positional.length >= 2 && positional[0] === 'init' && TOOLS.has(positional[1])) {
+    command = 'init';
+    tool = positional[1];
+    presetFromPositional = positional[2];
+  } else if (positional.length >= 2 && positional[0] === 'clean' && TOOLS.has(positional[1])) {
+    command = 'clean';
+    tool = positional[1];
+  } else if (positional.length >= 1) {
+    command = positional[0];
+    tool = positional[1];
+    if (command === 'init' && positional[2] && PRESET_NAME_RE.test(positional[2])) {
+      presetFromPositional = positional[2];
+    }
+  }
+
+  const preset = parsed.preset || presetFromPositional;
+  return { command, tool, preset };
+}
+
 /**
  * @returns {string | null} Error message or null if valid.
  */
 function validatePresetName(preset) {
   if (preset === undefined || preset === '') {
-    return 'Missing --preset <name>';
+    return 'Missing preset name (use --preset <name>, e.g. --preset next)';
   }
   if (!PRESET_NAME_RE.test(preset) || preset.includes('..')) {
     return (
@@ -91,9 +171,6 @@ function validatePresetName(preset) {
   return null;
 }
 
-/**
- * Ensures resolved preset dir stays under the tool presets root (defense in depth).
- */
 function assertPresetDirInsideRoot(presetsRoot, presetBase) {
   const root = path.resolve(presetsRoot);
   const resolved = path.resolve(presetBase);
@@ -117,10 +194,17 @@ function copyDir(src, dest) {
       copyDir(from, to);
     } else {
       fs.copyFileSync(from, to);
+      if (e.name.endsWith('.sh')) {
+        fs.chmodSync(to, 0o755);
+      }
     }
   }
 }
 
+function getOptionalDirs(cfg) {
+  return cfg.optionalCursorDirs || cfg.optionalClaudeDirs || [];
+}
+
 function removeDirIfExists(dir) {
   if (fs.existsSync(dir)) {
     fs.rmSync(dir, { recursive: true, force: true });
@@ -133,76 +217,171 @@ function removeFileIfExists(filePath) {
   }
 }
 
+function listPresetNames(presetsRoot) {
+  if (!fs.existsSync(presetsRoot)) {
+    return [];
+  }
+  return fs
+    .readdirSync(presetsRoot, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name)
+    .filter((name) => PRESET_NAME_RE.test(name));
+}
+
 function presetHasAnySource(base, cfg) {
   const rulesSrc = path.join(base, 'rules');
   const commandsSrc = path.join(base, 'commands');
   if (fs.existsSync(rulesSrc) || fs.existsSync(commandsSrc)) {
     return true;
   }
-  if (cfg.optionalClaudeDirs) {
-    for (const name of cfg.optionalClaudeDirs) {
-      if (fs.existsSync(path.join(base, name))) {
-        return true;
-      }
+  for (const name of getOptionalDirs(cfg)) {
+    if (fs.existsSync(path.join(base, name))) {
+      return true;
     }
   }
   if (cfg.claudeMdSrc && fs.existsSync(path.join(base, cfg.claudeMdSrc))) {
     return true;
   }
+  if (cfg.hooksJsonSrc && fs.existsSync(path.join(base, cfg.hooksJsonSrc))) {
+    return true;
+  }
+  if (cfg.mcpJsonSrc && fs.existsSync(path.join(base, cfg.mcpJsonSrc))) {
+    return true;
+  }
+  for (const name of cfg.toolRootFiles || []) {
+    if (fs.existsSync(path.join(base, name))) {
+      return true;
+    }
+  }
   return false;
 }
 
-function cmdInit(tool, preset) {
-  const cfg = PRESETS[tool];
-  if (!cfg) {
-    console.error(`Unknown tool: ${tool}. Use cursor or claude.`);
+function resolveTargetCwd(cwdOption) {
+  const cwd = cwdOption ? path.resolve(cwdOption) : process.cwd();
+  if (!fs.existsSync(cwd)) {
+    console.error(`Target directory does not exist: ${cwd}`);
     process.exit(1);
   }
-  const nameErr = validatePresetName(preset);
+  if (!fs.statSync(cwd).isDirectory()) {
+    console.error(`Target path is not a directory: ${cwd}`);
+    process.exit(1);
+  }
+  return cwd;
+}
+
+function resolvePresetName(tool, preset, packageRoot) {
+  const cfg = PRESETS[tool];
+  const presetsRoot = path.join(packageRoot, ...cfg.relBase);
+  let name = preset || DEFAULT_PRESET;
+
+  const nameErr = validatePresetName(name);
   if (nameErr) {
     console.error(nameErr);
     process.exit(1);
   }
-  const presetsRoot = path.join(packageRoot, ...cfg.relBase);
-  const base = path.join(presetsRoot, preset);
+
+  let base = path.join(presetsRoot, name);
+  if (!presetHasAnySource(base, cfg)) {
+    const available = listPresetNames(presetsRoot);
+    if (!preset && available.includes(DEFAULT_PRESET)) {
+      name = DEFAULT_PRESET;
+      base = path.join(presetsRoot, name);
+    } else {
+      console.error(`Preset "${name}" for ${tool} not found.`);
+      console.error(`Looked in: ${base}`);
+      console.error(`Package root: ${packageRoot}`);
+      if (available.length > 0) {
+        console.error(`Available presets: ${available.join(', ')}`);
+      } else {
+        console.error(`No presets directory at: ${presetsRoot}`);
+        console.error(
+          'The installed package may be incomplete. Reinstall @bonesofspring/ai-rules or run from the package source.',
+        );
+      }
+      process.exit(1);
+    }
+  }
+
   assertPresetDirInsideRoot(presetsRoot, base);
+  return { name, base, presetsRoot };
+}
+
+function cmdInit(tool, preset, cwdOption) {
+  const cfg = PRESETS[tool];
+  if (!cfg) {
+    console.error(`Unknown tool: ${tool}. Use cursor or claude.`);
+    process.exit(1);
+  }
+
+  const packageRoot = getPackageRoot();
+  const cwd = resolveTargetCwd(cwdOption);
+  const { name: presetName, base } = resolvePresetName(tool, preset, packageRoot);
 
   const rulesSrc = path.join(base, 'rules');
   const commandsSrc = path.join(base, 'commands');
-  const cwd = process.cwd();
+  const toolRoot = tool === 'cursor' ? '.cursor' : '.claude';
+  const toolRootAbs = path.join(cwd, toolRoot);
 
-  if (!presetHasAnySource(base, cfg)) {
-    console.error(`Preset "${preset}" for ${tool} not found under ${base}`);
-    process.exit(1);
-  }
+  fs.mkdirSync(toolRootAbs, { recursive: true });
+
+  let copiedSteps = 0;
 
   try {
     if (tool === 'claude' && cfg.claudeMdSrc) {
       const mdFrom = path.join(base, cfg.claudeMdSrc);
       if (fs.existsSync(mdFrom)) {
-        const claudeRoot = path.join(cwd, '.claude');
-        fs.mkdirSync(claudeRoot, { recursive: true });
-        fs.copyFileSync(mdFrom, path.join(claudeRoot, 'CLAUDE.md'));
-        console.log('Copied CLAUDE.md → .claude/CLAUDE.md');
+        fs.copyFileSync(mdFrom, path.join(toolRootAbs, 'CLAUDE.md'));
+        console.log(`Copied CLAUDE.md → ${path.join(toolRoot, 'CLAUDE.md')}`);
+        copiedSteps++;
       }
     }
 
     if (fs.existsSync(rulesSrc)) {
       copyDir(rulesSrc, path.join(cwd, cfg.rulesDir));
       console.log(`Copied rules → ${cfg.rulesDir}`);
+      copiedSteps++;
     }
     if (fs.existsSync(commandsSrc)) {
       copyDir(commandsSrc, path.join(cwd, cfg.commandsDir));
       console.log(`Copied commands → ${cfg.commandsDir}`);
+      copiedSteps++;
+    }
+
+    for (const name of getOptionalDirs(cfg)) {
+      const src = path.join(base, name);
+      if (fs.existsSync(src)) {
+        copyDir(src, path.join(toolRootAbs, name));
+        console.log(`Copied ${name}/ → ${toolRoot}/${name}/`);
+        copiedSteps++;
+      }
     }
 
-    if (tool === 'claude' && cfg.optionalClaudeDirs) {
-      for (const name of cfg.optionalClaudeDirs) {
-        const src = path.join(base, name);
-        if (fs.existsSync(src)) {
-          copyDir(src, path.join(cwd, '.claude', name));
-          console.log(`Copied ${name}/ → .claude/${name}/`);
-        }
+    if (tool === 'cursor' && cfg.hooksJsonSrc) {
+      const hooksFrom = path.join(base, cfg.hooksJsonSrc);
+      if (fs.existsSync(hooksFrom)) {
+        fs.copyFileSync(hooksFrom, path.join(toolRootAbs, 'hooks.json'));
+        console.log(`Copied hooks.json → ${toolRoot}/hooks.json`);
+        copiedSteps++;
+      }
+    }
+
+    if (cfg.mcpJsonSrc && cfg.mcpJsonDest) {
+      const mcpFrom = path.join(base, cfg.mcpJsonSrc);
+      if (fs.existsSync(mcpFrom)) {
+        const mcpDestAbs = path.join(cwd, cfg.mcpJsonDest);
+        fs.mkdirSync(path.dirname(mcpDestAbs), { recursive: true });
+        fs.copyFileSync(mcpFrom, mcpDestAbs);
+        console.log(`Copied ${cfg.mcpJsonSrc} → ${cfg.mcpJsonDest}`);
+        copiedSteps++;
+      }
+    }
+
+    for (const name of cfg.toolRootFiles || []) {
+      const from = path.join(base, name);
+      if (fs.existsSync(from)) {
+        fs.copyFileSync(from, path.join(toolRootAbs, name));
+        console.log(`Copied ${name} → ${toolRoot}/${name}`);
+        copiedSteps++;
       }
     }
   } catch (err) {
@@ -210,66 +389,100 @@ function cmdInit(tool, preset) {
     console.error(`init failed: ${msg}`);
     process.exit(1);
   }
+
+  if (copiedSteps === 0) {
+    console.error(`init failed: preset "${presetName}" had no files to copy from ${base}`);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(toolRootAbs)) {
+    console.error(`init failed: ${toolRootAbs} was not created`);
+    process.exit(1);
+  }
+
+  console.log(`Done. ${toolRoot} installed at ${toolRootAbs} (preset: ${presetName})`);
 }
 
-function cmdClean(tool) {
+function cmdClean(tool, cwdOption) {
   const cfg = PRESETS[tool];
   if (!cfg) {
     console.error(`Unknown tool: ${tool}. Use cursor or claude.`);
     process.exit(1);
   }
-  const cwd = process.cwd();
-  if (tool === 'cursor') {
-    removeDirIfExists(path.join(cwd, '.cursor'));
-    console.log('Removed .cursor (if present)');
-    return;
-  }
+  const cwd = resolveTargetCwd(cwdOption);
+  const toolRoot = tool === 'cursor' ? '.cursor' : '.claude';
+  const removedParts = [cfg.rulesDir, cfg.commandsDir];
+
   removeDirIfExists(path.join(cwd, cfg.rulesDir));
   removeDirIfExists(path.join(cwd, cfg.commandsDir));
-  if (tool === 'claude' && cfg.optionalClaudeDirs) {
-    for (const name of cfg.optionalClaudeDirs) {
-      removeDirIfExists(path.join(cwd, '.claude', name));
-    }
-    removeFileIfExists(path.join(cwd, '.claude', 'CLAUDE.md'));
-  }
-  console.log(
-    `Removed ${cfg.rulesDir} and ${cfg.commandsDir}` +
-      (tool === 'claude' && cfg.optionalClaudeDirs
-        ? `, optional .claude/{${cfg.optionalClaudeDirs.join(',')}}, and .claude/CLAUDE.md`
-        : '') +
-      ' (if present)',
-  );
+
+  const optionalDirs = getOptionalDirs(cfg);
+  for (const name of optionalDirs) {
+    removeDirIfExists(path.join(cwd, toolRoot, name));
+    removedParts.push(`${toolRoot}/${name}`);
+  }
+
+  if (cfg.claudeMdSrc) {
+    removeFileIfExists(path.join(cwd, toolRoot, 'CLAUDE.md'));
+    removedParts.push(`${toolRoot}/CLAUDE.md`);
+  }
+
+  if (cfg.hooksJsonSrc) {
+    removeFileIfExists(path.join(cwd, toolRoot, 'hooks.json'));
+    removedParts.push(`${toolRoot}/hooks.json`);
+  }
+
+  if (cfg.mcpJsonDest) {
+    removeFileIfExists(path.join(cwd, cfg.mcpJsonDest));
+    removedParts.push(cfg.mcpJsonDest);
+  }
+
+  for (const name of cfg.toolRootFiles || []) {
+    removeFileIfExists(path.join(cwd, toolRoot, name));
+    removedParts.push(`${toolRoot}/${name}`);
+  }
+
+  console.log(`Removed ${removedParts.join(', ')} (if present)`);
 }
 
 function main() {
   const argv = process.argv.slice(2);
-  if (argv.length === 0 || argv.includes('-h') || argv.includes('--help')) {
+  if (argv.length === 0) {
     printHelp();
     process.exit(0);
   }
 
   const parsed = parseArgs(argv);
-  const [command, tool] = parsed._;
+  if (parsed.help) {
+    printHelp();
+    process.exit(0);
+  }
 
   if (parsed.presetError) {
     console.error(parsed.presetError);
     process.exit(1);
   }
+  if (parsed.cwdError) {
+    console.error(parsed.cwdError);
+    process.exit(1);
+  }
+
+  const { command, tool, preset } = normalizeInitClean(parsed);
 
   if (command === 'init') {
-    if (!tool) {
-      console.error('Missing <cursor|claude> after init.');
+    if (!tool || !TOOLS.has(tool)) {
+      console.error('Missing or invalid tool. Use: init cursor|claude [--preset next]');
       process.exit(1);
     }
-    cmdInit(tool, parsed.preset);
+    cmdInit(tool, preset, parsed.cwd);
     return;
   }
   if (command === 'clean') {
-    if (!tool) {
-      console.error('Missing <cursor|claude> after clean.');
+    if (!tool || !TOOLS.has(tool)) {
+      console.error('Missing or invalid tool. Use: clean cursor|claude');
       process.exit(1);
     }
-    cmdClean(tool);
+    cmdClean(tool, parsed.cwd);
     return;
   }
 

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@bonesofspring/ai-rules",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Presets of Cursor and Claude rules/commands for Revy Ross personal use",
   "license": "MIT",
   "author": "Revy Ross",
   "repository": {
     "type": "git",
-    "url": "https://github.com/bonesofspring/ai-rules.git"
+    "url": "git+https://github.com/bonesofspring/ai-rules.git"
   },
   "keywords": [
     "cursor",
@@ -20,6 +20,7 @@
   },
   "files": [
     "README.md",
+    "CHANGELOG.md",
     "bin",
     "presets"
   ],