create-standards 1.0.0

package/README.md

@@ -0,0 +1,89 @@
+# create-standards
+
+Install coding standards for known tech stacks into your project. Copies Cursor rules, Claude Code skills, and Antigravity skills so each tool picks them up automatically — no extra config.
+
+## Install / run
+
+```bash
+# one-shot
+npx create-standards --list
+npx create-standards rails
+npx create-standards rails --cursor
+
+# or via npm create
+npm create standards -- --list
+npm create standards -- rails
+npm create standards -- rails --cursor
+
+# global
+npm i -g create-standards
+create-standards rails --claude
+create-standards rails --cursor
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `create-standards --list` | List stacks and example commands |
+| `create-standards <stack>` | Install **all** IDE packs + `shared-reference/` |
+| `create-standards <stack> --cursor` | Cursor only → `.cursor/` |
+| `create-standards <stack> --claude` | Claude Code only → `.claude/` |
+| `create-standards <stack> --antigravity` | Antigravity only → `.agents/` |
+| `create-standards <stack> --cursor --claude` | Multiple IDEs |
+| `create-standards` (no args, TTY) | Interactive picker |
+
+Aliases: `--available-stack` for `--list`, `--claude-code` for `--claude`.
+
+### Options
+
+| Flag | Meaning |
+|---|---|
+| `--path <dir>` / `-C <dir>` | Install into another directory (default: cwd) |
+| `--force` | Overwrite existing destinations |
+| `--dry-run` | Print destinations without writing |
+| `--no-shared` | Skip `shared-reference/` |
+| `-h` / `--help` | Help |
+
+## What gets created
+
+For a full install of `rails`:
+
+```text
+.cursor/          # from standards/rails-standards/cursor/.cursor
+.claude/          # from standards/rails-standards/claude-code/.claude
+.agents/          # from standards/rails-standards/antigravity/.agents
+shared-reference/ # human-readable source docs
+```
+
+These paths are what Cursor, Claude Code, and Antigravity already look for — no parent wrapper folder.
+
+## Available stacks
+
+Stacks are discovered automatically from the package’s `standards/` folder. Adding a new directory (for example `standards/django-standards/`) with the same IDE layout makes it show up in `--list` and installable as `create-standards django` after you publish a new version.
+
+Current packs in this repo:
+
+- `rails` (`rails-standards`)
+- `nodejs-express` (`nodejs-express-standards`)
+
+## Local development
+
+From this repo (without publishing):
+
+```bash
+node bin/create-standards.js --list
+node bin/create-standards.js rails --dry-run
+node bin/create-standards.js rails --cursor --path /tmp/test-app --force
+```
+
+## Publish
+
+```bash
+npm login
+npm publish
+```
+
+## License
+
+ISC

package/bin/create-standards.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../src/cli').run(process.argv.slice(2));

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "create-standards",
+  "version": "1.0.0",
+  "description": "Install coding standards (Cursor, Claude Code, Antigravity) for known tech stacks into your project",
+  "main": "src/cli.js",
+  "bin": {
+    "create-standards": "./bin/create-standards.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "standards"
+  ],
+  "scripts": {
+    "start": "node bin/create-standards.js",
+    "test": "node bin/create-standards.js --list"
+  },
+  "keywords": [
+    "standards",
+    "cursor",
+    "claude",
+    "antigravity",
+    "coding-standards",
+    "create-standards"
+  ],
+  "author": "Sakshi Jain",
+  "license": "ISC",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/cli.js

@@ -0,0 +1,355 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { listAvailableStacks, findStackByName } = require('./discover');
+const { getIdeFolderFromFlag } = require('./ide-config');
+const { copyStandardsIntoProject } = require('./install');
+
+const RESERVED_FLAGS = new Set([
+  'list',
+  'available-stack',
+  'available-stacks',
+  'help',
+  'h',
+  'dry-run',
+  'force',
+  'path',
+  'C',
+  'no-shared',
+  'stack',
+]);
+
+const FLAG_DISPLAY_ORDER = ['cursor', 'claude', 'claude-code', 'antigravity'];
+
+function sortIdeFlags(flags) {
+  return [...flags].sort((a, b) => {
+    const orderA = FLAG_DISPLAY_ORDER.indexOf(a);
+    const orderB = FLAG_DISPLAY_ORDER.indexOf(b);
+    const rankA = orderA === -1 ? Number.MAX_SAFE_INTEGER : orderA;
+    const rankB = orderB === -1 ? Number.MAX_SAFE_INTEGER : orderB;
+    if (rankA !== rankB) return rankA - rankB;
+    return a.localeCompare(b);
+  });
+}
+
+function getDisplayFlagsForStack(stack) {
+  const flags = sortIdeFlags(stack.idePacks.flatMap((pack) => pack.flags));
+  return flags.map((flag) => `--${flag}`);
+}
+
+function printHelp(stacks) {
+  const stackLines =
+    stacks.length === 0
+      ? '  (no stacks found under standards/)'
+      : stacks
+          .map((stack) => {
+            const flags = getDisplayFlagsForStack(stack);
+            return (
+              `  ${stack.shortName}  (${stack.folderName})\n` +
+              `    Flags: ${flags.length ? flags.join(', ') : '(none)'}\n` +
+              `    create-standards ${stack.shortName}\n` +
+              `    create-standards ${stack.shortName}${flags[0] ? ` ${flags[0]}` : ''}`
+            );
+          })
+          .join('\n\n');
+
+  console.log(`Usage:
+  create-standards --list
+  create-standards <stack> [--cursor] [--claude] [--antigravity] [options]
+  create-standards --stack <stack> [options]
+
+Install coding standards into the current project directory.
+Without IDE flags, all available IDEs for that stack are installed.
+
+Options:
+  --list, --available-stack   List stacks and example commands
+  --stack <name>              Stack to install (alternative to positional)
+  --cursor                    Install Cursor rules only (.cursor/)
+  --claude, --claude-code     Install Claude Code skill only (.claude/)
+  --antigravity               Install Antigravity skill only (.agents/)
+  --path <dir>, -C <dir>      Target directory (default: cwd)
+  --force                     Overwrite existing destinations
+  --dry-run                   Show what would be copied
+  --no-shared                 Skip shared-reference/
+  -h, --help                  Show help
+
+Available stacks:
+
+${stackLines}
+`);
+}
+
+function printAvailableStacks(stacks) {
+  if (stacks.length === 0) {
+    console.log('No stacks found under standards/.');
+    return;
+  }
+
+  console.log('Available stacks:\n');
+  for (const stack of stacks) {
+    const flags = getDisplayFlagsForStack(stack);
+    console.log(`  ${stack.shortName}  (${stack.folderName})`);
+    console.log(`    Flags: ${flags.length ? flags.join(', ') : '(none)'}`);
+    console.log(`    create-standards ${stack.shortName}`);
+    if (flags[0]) {
+      console.log(`    create-standards ${stack.shortName} ${flags[0]}`);
+    }
+    console.log('');
+  }
+}
+
+function parseCommandLineArgs(argv) {
+  const options = {
+    help: false,
+    list: false,
+    stackName: null,
+    ideFlags: [],
+    targetFolder: process.cwd(),
+    force: false,
+    dryRun: false,
+    includeSharedReference: true,
+    extraArgs: [],
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+      continue;
+    }
+    if (arg === '--list' || arg === '--available-stack' || arg === '--available-stacks') {
+      options.list = true;
+      continue;
+    }
+    if (arg === '--force') {
+      options.force = true;
+      continue;
+    }
+    if (arg === '--dry-run') {
+      options.dryRun = true;
+      continue;
+    }
+    if (arg === '--no-shared') {
+      options.includeSharedReference = false;
+      continue;
+    }
+    if (arg === '--path' || arg === '-C') {
+      const value = argv[++i];
+      if (!value) throw new Error(`${arg} requires a directory path`);
+      options.targetFolder = path.resolve(value);
+      continue;
+    }
+    if (arg.startsWith('--path=')) {
+      options.targetFolder = path.resolve(arg.slice('--path='.length));
+      continue;
+    }
+    if (arg === '--stack') {
+      const value = argv[++i];
+      if (!value) throw new Error('--stack requires a name');
+      options.stackName = value;
+      continue;
+    }
+    if (arg.startsWith('--stack=')) {
+      options.stackName = arg.slice('--stack='.length);
+      continue;
+    }
+
+    if (arg.startsWith('--')) {
+      const flag = arg.slice(2);
+      if (RESERVED_FLAGS.has(flag)) {
+        throw new Error(`Unexpected use of --${flag}`);
+      }
+      options.ideFlags.push(flag);
+      continue;
+    }
+
+    if (arg.startsWith('-') && arg.length > 1) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+
+    options.extraArgs.push(arg);
+  }
+
+  if (!options.stackName && options.extraArgs.length > 0) {
+    options.stackName = options.extraArgs[0];
+  }
+  if (options.extraArgs.length > 1) {
+    throw new Error(
+      `Unexpected arguments: ${options.extraArgs.slice(1).join(', ')}. ` +
+        'Pass IDE choices as flags, e.g. --cursor'
+    );
+  }
+
+  return options;
+}
+
+// Empty array means install every IDE for the stack
+function resolveSelectedIdeFolders(ideFlags, stack) {
+  if (ideFlags.length === 0) return [];
+
+  const selected = [];
+  const seen = new Set();
+
+  for (const flag of ideFlags) {
+    const ideFolder = getIdeFolderFromFlag(flag);
+    const match = stack.idePacks.find(
+      (pack) => pack.ideFolder === ideFolder || pack.flags.includes(flag)
+    );
+
+    if (!match) {
+      const available = stack.idePacks.flatMap((pack) =>
+        pack.flags.map((name) => `--${name}`)
+      );
+      throw new Error(
+        `Unknown or unavailable IDE flag --${flag} for stack "${stack.shortName}".\n` +
+          `Available: ${available.length ? available.join(', ') : '(none)'}`
+      );
+    }
+
+    if (!seen.has(match.ideFolder)) {
+      seen.add(match.ideFolder);
+      selected.push(match.ideFolder);
+    }
+  }
+
+  return selected;
+}
+
+function askQuestion(rl, prompt) {
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => resolve(answer.trim()));
+  });
+}
+
+async function promptForStackAndIde(stacks) {
+  if (stacks.length === 0) {
+    throw new Error('No stacks found under standards/.');
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    console.log('Available stacks:\n');
+    stacks.forEach((stack, index) => {
+      console.log(`  ${index + 1}. ${stack.shortName}`);
+    });
+    console.log('');
+
+    const stackAnswer = await askQuestion(rl, `Choose a stack [1-${stacks.length}]: `);
+    const stackIndex = Number.parseInt(stackAnswer, 10);
+    if (!Number.isInteger(stackIndex) || stackIndex < 1 || stackIndex > stacks.length) {
+      throw new Error('Invalid stack selection.');
+    }
+    const stack = stacks[stackIndex - 1];
+
+    console.log('\nInstall target:\n');
+    console.log('  1. All IDEs');
+    stack.idePacks.forEach((pack, index) => {
+      console.log(
+        `  ${index + 2}. ${pack.ideFolder} (${pack.flags.map((flag) => `--${flag}`).join(', ')})`
+      );
+    });
+    console.log('');
+
+    const ideAnswer = await askQuestion(
+      rl,
+      `Choose IDE [1-${stack.idePacks.length + 1}] (default 1): `
+    );
+    const ideIndex = ideAnswer === '' ? 1 : Number.parseInt(ideAnswer, 10);
+    if (
+      !Number.isInteger(ideIndex) ||
+      ideIndex < 1 ||
+      ideIndex > stack.idePacks.length + 1
+    ) {
+      throw new Error('Invalid IDE selection.');
+    }
+
+    return {
+      stackName: stack.shortName,
+      selectedIdeFolders: ideIndex === 1 ? [] : [stack.idePacks[ideIndex - 2].ideFolder],
+    };
+  } finally {
+    rl.close();
+  }
+}
+
+function installAndReport(stack, selectedIdeFolders, options) {
+  const { createdPaths } = copyStandardsIntoProject({
+    stack,
+    selectedIdeFolders,
+    targetFolder: options.targetFolder,
+    force: options.force,
+    dryRun: options.dryRun,
+    includeSharedReference: options.includeSharedReference,
+  });
+
+  console.log(options.dryRun ? '[dry-run] Would create:' : 'Created:');
+  for (const createdPath of createdPaths) {
+    console.log(`  ${createdPath}`);
+  }
+  if (!options.dryRun) {
+    console.log(
+      `\nInstalled "${stack.shortName}" standards into ${path.resolve(options.targetFolder)}`
+    );
+  }
+}
+
+function ensureTargetFolderExists(targetFolder) {
+  if (!fs.existsSync(targetFolder)) {
+    fs.mkdirSync(targetFolder, { recursive: true });
+  }
+}
+
+async function run(argv) {
+  try {
+    const stacks = listAvailableStacks();
+    const options = parseCommandLineArgs(argv);
+
+    if (options.help) {
+      printHelp(stacks);
+      return;
+    }
+
+    if (options.list) {
+      printAvailableStacks(stacks);
+      return;
+    }
+
+    if (!options.stackName) {
+      if (!process.stdin.isTTY) {
+        printHelp(stacks);
+        process.exitCode = 1;
+        return;
+      }
+
+      const choice = await promptForStackAndIde(stacks);
+      const stack = findStackByName(choice.stackName);
+      if (!stack) throw new Error(`Unknown stack: ${choice.stackName}`);
+
+      ensureTargetFolderExists(options.targetFolder);
+      installAndReport(stack, choice.selectedIdeFolders, options);
+      return;
+    }
+
+    const stack = findStackByName(options.stackName);
+    if (!stack) {
+      const names = stacks.map((item) => item.shortName).join(', ');
+      throw new Error(
+        `Unknown stack "${options.stackName}". Available: ${names || '(none)'}`
+      );
+    }
+
+    const selectedIdeFolders = resolveSelectedIdeFolders(options.ideFlags, stack);
+    ensureTargetFolderExists(options.targetFolder);
+    installAndReport(stack, selectedIdeFolders, options);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = { run, parseCommandLineArgs };

package/src/discover.js

@@ -0,0 +1,113 @@
+const fs = require('fs');
+const path = require('path');
+const {
+  IDE_CONFIG,
+  getStackShortName,
+  getFlagsForIde,
+  getInstallPathsForIde,
+} = require('./ide-config');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const STANDARDS_FOLDER = path.join(PACKAGE_ROOT, 'standards');
+
+function isDirectory(filePath) {
+  return fs.existsSync(filePath) && fs.statSync(filePath).isDirectory();
+}
+
+// Find IDE packs inside one stack folder (cursor/, claude-code/, antigravity/, …)
+function findIdePacksInStack(stackPath) {
+  if (!isDirectory(stackPath)) return [];
+
+  const idePacks = [];
+
+  for (const entry of fs.readdirSync(stackPath, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === 'shared-reference' || entry.name.startsWith('.')) continue;
+
+    const ideFolder = entry.name;
+    const idePath = path.join(stackPath, ideFolder);
+
+    if (IDE_CONFIG[ideFolder]) {
+      const { sourceFolder, installAs } = getInstallPathsForIde(ideFolder);
+      const sourcePath = path.join(idePath, sourceFolder);
+      if (isDirectory(sourcePath)) {
+        idePacks.push({
+          ideFolder,
+          sourcePath,
+          installAs,
+          flags: getFlagsForIde(ideFolder),
+        });
+      }
+      continue;
+    }
+
+    // Newer IDE folders: look for .<name> or a single hidden nested folder
+    const preferredSource = path.join(idePath, `.${ideFolder}`);
+    if (isDirectory(preferredSource)) {
+      idePacks.push({
+        ideFolder,
+        sourcePath: preferredSource,
+        installAs: `.${ideFolder}`,
+        flags: getFlagsForIde(ideFolder),
+      });
+      continue;
+    }
+
+    const hiddenFolders = fs
+      .readdirSync(idePath, { withFileTypes: true })
+      .filter((child) => child.isDirectory() && child.name.startsWith('.'));
+
+    if (hiddenFolders.length === 1) {
+      idePacks.push({
+        ideFolder,
+        sourcePath: path.join(idePath, hiddenFolders[0].name),
+        installAs: hiddenFolders[0].name,
+        flags: getFlagsForIde(ideFolder),
+      });
+    }
+  }
+
+  return idePacks.sort((a, b) => a.ideFolder.localeCompare(b.ideFolder));
+}
+
+function listAvailableStacks() {
+  if (!isDirectory(STANDARDS_FOLDER)) return [];
+
+  return fs
+    .readdirSync(STANDARDS_FOLDER, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+    .map((entry) => {
+      const stackPath = path.join(STANDARDS_FOLDER, entry.name);
+      const sharedReferencePath = path.join(stackPath, 'shared-reference');
+      const hasSharedReference = isDirectory(sharedReferencePath);
+
+      return {
+        folderName: entry.name,
+        shortName: getStackShortName(entry.name),
+        path: stackPath,
+        idePacks: findIdePacksInStack(stackPath),
+        hasSharedReference,
+        sharedReferencePath: hasSharedReference ? sharedReferencePath : null,
+      };
+    })
+    .sort((a, b) => a.shortName.localeCompare(b.shortName));
+}
+
+function findStackByName(name) {
+  const normalized = name.trim().toLowerCase();
+  return (
+    listAvailableStacks().find(
+      (stack) =>
+        stack.shortName.toLowerCase() === normalized ||
+        stack.folderName.toLowerCase() === normalized
+    ) || null
+  );
+}
+
+module.exports = {
+  PACKAGE_ROOT,
+  STANDARDS_FOLDER,
+  listAvailableStacks,
+  findIdePacksInStack,
+  findStackByName,
+};

package/src/ide-config.js

@@ -0,0 +1,57 @@
+// Maps each IDE folder under a stack to CLI flags and where files land in the project.
+const IDE_CONFIG = {
+  cursor: {
+    folder: 'cursor',
+    sourceFolder: '.cursor',
+    installAs: '.cursor',
+    flags: ['cursor'],
+  },
+  'claude-code': {
+    folder: 'claude-code',
+    sourceFolder: '.claude',
+    installAs: '.claude',
+    flags: ['claude', 'claude-code'],
+  },
+  antigravity: {
+    folder: 'antigravity',
+    sourceFolder: '.agents',
+    installAs: '.agents',
+    flags: ['antigravity'],
+  },
+};
+
+// "rails-skills" → "rails"
+function getStackShortName(folderName) {
+  return folderName.endsWith('-skills')
+    ? folderName.slice(0, -'-skills'.length)
+    : folderName;
+}
+
+// "--claude" → "claude-code"; unknown flags map 1:1 to a folder name
+function getIdeFolderFromFlag(flag) {
+  for (const ide of Object.values(IDE_CONFIG)) {
+    if (ide.flags.includes(flag)) return ide.folder;
+  }
+  return flag || null;
+}
+
+function getFlagsForIde(ideFolder) {
+  const known = IDE_CONFIG[ideFolder];
+  return known ? known.flags : [ideFolder];
+}
+
+function getInstallPathsForIde(ideFolder) {
+  const known = IDE_CONFIG[ideFolder];
+  if (known) {
+    return { sourceFolder: known.sourceFolder, installAs: known.installAs };
+  }
+  return { sourceFolder: `.${ideFolder}`, installAs: `.${ideFolder}` };
+}
+
+module.exports = {
+  IDE_CONFIG,
+  getStackShortName,
+  getIdeFolderFromFlag,
+  getFlagsForIde,
+  getInstallPathsForIde,
+};