@bonesofspring/ai-rules 0.1.41 → 0.1.42

package/README.md

@@ -13,7 +13,16 @@ 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:
+
+```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 cursor` / `clean claude` removes what this CLI installs: `rules`, `commands`, optional `agents`, `hooks`, `skills`, `team`, Cursor `hooks.json` / `BUGBOT.md`, and Claude `CLAUDE.md` when present. Other files under `.cursor/` or `.claude/` are left intact.
 

package/bin/cli.js

@@ -5,58 +5,86 @@
 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'],
-    /** Optional dirs under preset root → under `.cursor/` (recursive copy). */
     optionalCursorDirs: ['agents', 'hooks', 'skills', 'team'],
-    /** Copied from preset root to `.cursor/hooks.json` when present. */
     hooksJsonSrc: 'hooks.json',
-    /** Optional files under preset root → under `.cursor/`. */
     toolRootFiles: ['BUGBOT.md', 'AGENTS.md'],
   },
   claude: {
     rulesDir: '.claude/rules',
     commandsDir: '.claude/commands',
     relBase: ['presets', 'claude'],
-    /** Optional dirs under preset root → under `.claude/` (recursive copy). */
     optionalClaudeDirs: ['skills', 'agents', 'hooks', 'team'],
-    /** Copied from preset root to `.claude/CLAUDE.md` when present. */
     claudeMdSrc: 'CLAUDE.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.
-  Cursor init also copies agents/, hooks/, skills/, team/, hooks.json, BUGBOT.md, and AGENTS.md when present.
-  Claude init also copies agents/, hooks/, skills/, team/, and CLAUDE.md when present.
-  clean removes only paths installed by this CLI; other tool files are left intact.
-  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.
+  Claude init copies rules, commands, skills, agents, hooks, team, and CLAUDE.md when present.
+  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 clean claude
+  npx @bonesofspring/ai-rules init cursor next
+  npx @bonesofspring/ai-rules init 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('-')) {
@@ -77,17 +105,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 (
@@ -98,9 +162,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);
@@ -147,6 +208,17 @@ 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');
@@ -172,74 +244,121 @@ function presetHasAnySource(base, cfg) {
   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++;
     }
 
-    const toolRoot = tool === 'cursor' ? '.cursor' : '.claude';
     for (const name of getOptionalDirs(cfg)) {
       const src = path.join(base, name);
       if (fs.existsSync(src)) {
-        copyDir(src, path.join(cwd, toolRoot, name));
+        copyDir(src, path.join(toolRootAbs, name));
         console.log(`Copied ${name}/ → ${toolRoot}/${name}/`);
+        copiedSteps++;
       }
     }
 
     if (tool === 'cursor' && cfg.hooksJsonSrc) {
       const hooksFrom = path.join(base, cfg.hooksJsonSrc);
       if (fs.existsSync(hooksFrom)) {
-        fs.mkdirSync(path.join(cwd, '.cursor'), { recursive: true });
-        fs.copyFileSync(hooksFrom, path.join(cwd, '.cursor', 'hooks.json'));
-        console.log('Copied hooks.json → .cursor/hooks.json');
+        fs.copyFileSync(hooksFrom, path.join(toolRootAbs, 'hooks.json'));
+        console.log(`Copied hooks.json → ${toolRoot}/hooks.json`);
+        copiedSteps++;
       }
     }
 
     for (const name of cfg.toolRootFiles || []) {
       const from = path.join(base, name);
       if (fs.existsSync(from)) {
-        fs.mkdirSync(path.join(cwd, toolRoot), { recursive: true });
-        fs.copyFileSync(from, path.join(cwd, toolRoot, name));
+        fs.copyFileSync(from, path.join(toolRootAbs, name));
         console.log(`Copied ${name} → ${toolRoot}/${name}`);
+        copiedSteps++;
       }
     }
   } catch (err) {
@@ -247,15 +366,27 @@ 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();
+  const cwd = resolveTargetCwd(cwdOption);
   const toolRoot = tool === 'cursor' ? '.cursor' : '.claude';
   const removedParts = [cfg.rulesDir, cfg.commandsDir];
 
@@ -288,33 +419,42 @@ function cmdClean(tool) {
 
 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,6 +1,6 @@
 {
   "name": "@bonesofspring/ai-rules",
-  "version": "0.1.41",
+  "version": "0.1.42",
   "description": "Presets of Cursor and Claude rules/commands for Revy Ross personal use",
   "license": "MIT",
   "author": "Revy Ross",