cursor-lint 0.12.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-lint",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Lint your Cursor rules — catch common mistakes before they break your workflow",
   "main": "src/index.js",
   "bin": {

package/src/cli.js

@@ -5,10 +5,10 @@ const { lintProject } = require('./index');
 const { verifyProject } = require('./verify');
 const { initProject } = require('./init');
 const { fixProject } = require('./fix');
-const { generateRules, suggestSkills } = require('./generate');
+const { generateRules, suggestSkills, listPresets, generateFromPreset } = require('./generate');
 const { checkVersions, checkRuleVersionMismatches } = require('./versions');
 
-const VERSION = '0.12.0';
+const VERSION = '0.13.0';
 
 const RED = '\x1b[31m';
 const YELLOW = '\x1b[33m';
@@ -34,6 +34,8 @@ ${YELLOW}Options:${RESET}
   --init         Generate starter .mdc rules (auto-detects your stack)
   --fix          Auto-fix common issues (missing frontmatter, alwaysApply)
   --generate     Auto-detect stack & download matching .mdc rules from GitHub
+  --generate --preset <name>  Install rules for a popular stack preset
+  --generate --preset list    Show available presets
   --order        Show rule load order, priority tiers, and token estimates
   --version-check  Detect installed package versions and show relevant rule tips
 
@@ -208,13 +210,85 @@ async function main() {
     process.exit(0);
 
   } else if (isGenerate) {
+    // Check for --preset flag
+    const presetIndex = args.indexOf('--preset');
+    const hasPreset = presetIndex !== -1;
+    const presetValue = hasPreset ? args[presetIndex + 1] : null;
+
+    // Handle --preset list
+    if (hasPreset && presetValue === 'list') {
+      console.log(`\n🚀 cursor-lint v${VERSION} --generate --preset list\n`);
+      console.log(`${CYAN}Available presets:${RESET}\n`);
+      
+      const presets = listPresets();
+      for (const [key, preset] of Object.entries(presets)) {
+        const paddedKey = key.padEnd(12);
+        console.log(`  ${GREEN}${paddedKey}${RESET} ${preset.name} — ${DIM}${preset.description}${RESET}`);
+      }
+      
+      console.log(`\n${YELLOW}Usage:${RESET} cursor-lint --generate --preset t3\n`);
+      process.exit(0);
+    }
+
+    // Handle --preset <name>
+    if (hasPreset && presetValue && presetValue !== 'list') {
+      console.log(`\n🚀 cursor-lint v${VERSION} --generate --preset ${presetValue}\n`);
+      
+      const presets = listPresets();
+      if (!presets[presetValue]) {
+        console.log(`${RED}Unknown preset: ${presetValue}${RESET}\n`);
+        console.log(`Run ${CYAN}cursor-lint --generate --preset list${RESET} to see available presets\n`);
+        process.exit(1);
+      }
+
+      const results = await generateFromPreset(cwd, presetValue);
+      
+      console.log(`${CYAN}Preset:${RESET} ${results.presetInfo.name}`);
+      console.log(`${DIM}${results.presetInfo.description}${RESET}\n`);
+
+      if (results.created.length > 0) {
+        console.log(`${GREEN}Downloaded:${RESET}`);
+        for (const r of results.created) {
+          console.log(`  ${GREEN}✓${RESET} .cursor/rules/${r.file}`);
+        }
+      }
+
+      if (results.skipped.length > 0) {
+        console.log(`\n${YELLOW}Skipped (already exist):${RESET}`);
+        for (const r of results.skipped) {
+          console.log(`  ${YELLOW}⚠${RESET} .cursor/rules/${r.file}`);
+        }
+      }
+
+      if (results.failed.length > 0) {
+        console.log(`\n${RED}Failed:${RESET}`);
+        for (const r of results.failed) {
+          console.log(`  ${RED}✗${RESET} ${r.file} — ${r.error}`);
+        }
+      }
+
+      if (results.created.length > 0) {
+        console.log(`\n${DIM}Run cursor-lint to check these rules${RESET}\n`);
+      }
+
+      process.exit(results.failed.length > 0 ? 1 : 0);
+    }
+
+    // Regular --generate (no preset)
     console.log(`\n🚀 cursor-lint v${VERSION} --generate\n`);
     console.log(`Detecting stack in ${cwd}...\n`);
 
     const results = await generateRules(cwd);
 
     if (results.detected.length > 0) {
-      console.log(`${CYAN}Detected:${RESET} ${results.detected.join(', ')}\n`);
+      console.log(`${CYAN}Detected stack:${RESET} ${results.detected.join(', ')}`);
+      
+      // Show versions if available
+      if (results.versions && Object.keys(results.versions).length > 0) {
+        const versionStrs = Object.entries(results.versions).map(([dep, ver]) => `${dep}@${ver}`);
+        console.log(`${CYAN}Versions:${RESET} ${versionStrs.join(', ')}`);
+      }
+      console.log();
     } else {
       console.log(`${YELLOW}No recognized stack detected.${RESET}`);
       console.log(`${DIM}Supports: package.json, tsconfig.json, requirements.txt, pyproject.toml,${RESET}`);
@@ -250,6 +324,13 @@ async function main() {
       }
     }
 
+    if (results.fallbacks && results.fallbacks.length > 0) {
+      console.log(`\n${YELLOW}Fallbacks (version-specific rule not found):${RESET}`);
+      for (const r of results.fallbacks) {
+        console.log(`  ${YELLOW}⚠${RESET} ${r.from} → ${r.to} ${DIM}(${r.stack})${RESET}`);
+      }
+    }
+
     if (results.failed.length > 0) {
       console.log(`\n${RED}Failed:${RESET}`);
       for (const r of results.failed) {

package/src/generate.js

@@ -4,6 +4,32 @@ const https = require('https');
 
 const BASE_URL = 'https://raw.githubusercontent.com/nedcodes-ok/cursorrules-collection/main/rules-mdc/';
 
+// Version-specific rule overrides: if user has react 19, use react-19.mdc instead of react.mdc
+const VERSION_RULES = {
+  'react': {
+    '19': 'frameworks/react-19.mdc',
+    '18': 'frameworks/react-18.mdc',
+  },
+  'next': {
+    '15': 'frameworks/nextjs-15.mdc',
+    '14': 'frameworks/nextjs-14.mdc',
+    '13': 'frameworks/nextjs-13.mdc',
+  },
+  'vue': {
+    '3': 'frameworks/vue-3.mdc',
+    '2': 'frameworks/vue-2.mdc',
+  },
+  '@angular/core': {
+    '19': 'frameworks/angular-19.mdc',
+    '18': 'frameworks/angular-18.mdc',
+    '17': 'frameworks/angular-17.mdc',
+  },
+  'svelte': {
+    '5': 'frameworks/svelte-5.mdc',
+    '4': 'frameworks/svelte-4.mdc',
+  },
+};
+
 // package.json dependencies → rule files
 const PKG_DEP_MAP = {
   // Frameworks
@@ -189,6 +215,7 @@ function detectStack(cwd) {
   const detected = [];
   const rules = new Map(); // rulePath -> stackName
   const allDetectedDeps = [];
+  const versions = {}; // dep -> version string
 
   // package.json
   const pkgPath = path.join(cwd, 'package.json');
@@ -201,7 +228,21 @@ function detectStack(cwd) {
         if (pkgDeps[dep]) {
           detected.push(dep);
           allDetectedDeps.push(dep);
-          rules.set(rule, dep);
+          
+          // Extract version
+          const rawVersion = pkgDeps[dep];
+          versions[dep] = rawVersion;
+          
+          // Parse major version (strip ^, ~, >=, etc.)
+          const versionMatch = rawVersion.match(/(\d+)/);
+          const majorVersion = versionMatch ? versionMatch[1] : null;
+          
+          // Check if version-specific rule exists
+          if (majorVersion && VERSION_RULES[dep] && VERSION_RULES[dep][majorVersion]) {
+            rules.set(VERSION_RULES[dep][majorVersion], dep);
+          } else {
+            rules.set(rule, dep);
+          }
         }
       }
     } catch {}
@@ -406,18 +447,19 @@ function detectStack(cwd) {
     }
   }
 
-  return { detected, rules };
+  return { detected, rules, versions };
 }
 
 async function generateRules(cwd) {
-  const { detected, rules } = detectStack(cwd);
+  const { detected, rules, versions } = detectStack(cwd);
   const rulesDir = path.join(cwd, '.cursor', 'rules');
   const created = [];
   const skipped = [];
   const failed = [];
+  const fallbacks = [];
 
   if (rules.size === 0) {
-    return { detected, created, skipped, failed };
+    return { detected, created, skipped, failed, versions };
   }
 
   fs.mkdirSync(rulesDir, { recursive: true });
@@ -437,13 +479,130 @@ async function generateRules(cwd) {
       fs.writeFileSync(destPath, content, 'utf8');
       created.push({ file: filename, stack: stackName });
     } catch (err) {
-      failed.push({ file: filename, stack: stackName, error: err.message });
+      // Try fallback to generic rule if this was a version-specific rule
+      const genericRule = PKG_DEP_MAP[stackName];
+      if (genericRule && genericRule !== rulePath) {
+        try {
+          const fallbackUrl = BASE_URL + genericRule;
+          const content = await fetchFile(fallbackUrl);
+          const genericFilename = path.basename(genericRule);
+          const genericDestPath = path.join(rulesDir, genericFilename);
+          fs.writeFileSync(genericDestPath, content, 'utf8');
+          created.push({ file: genericFilename, stack: stackName });
+          fallbacks.push({ from: filename, to: genericFilename, stack: stackName });
+        } catch (fallbackErr) {
+          failed.push({ file: filename, stack: stackName, error: err.message });
+        }
+      } else {
+        failed.push({ file: filename, stack: stackName, error: err.message });
+      }
     }
   }
 
-  return { detected, created, skipped, failed };
+  return { detected, created, skipped, failed, versions, fallbacks };
 }
 
+const STACK_PRESETS = {
+  't3': {
+    name: 'T3 Stack',
+    description: 'Next.js + TypeScript + Tailwind + tRPC + Prisma + NextAuth',
+    rules: [
+      'languages/typescript.mdc',
+      'frameworks/nextjs.mdc',
+      'frameworks/tailwind-css.mdc',
+      'frameworks/zod.mdc',
+      'frameworks/t3-stack.mdc',
+      'tools/trpc.mdc',
+      'tools/prisma.mdc',
+      'tools/nextauth.mdc',
+      'practices/clean-code.mdc',
+      'practices/error-handling.mdc',
+    ],
+  },
+  'mern': {
+    name: 'MERN Stack',
+    description: 'MongoDB + Express + React + Node.js',
+    rules: [
+      'languages/typescript.mdc',
+      'languages/javascript.mdc',
+      'frameworks/react.mdc',
+      'frameworks/express.mdc',
+      'tools/mongodb.mdc',
+      'practices/api-design.mdc',
+      'practices/error-handling.mdc',
+      'practices/clean-code.mdc',
+    ],
+  },
+  'fastapi': {
+    name: 'Python FastAPI',
+    description: 'FastAPI + Pydantic + SQLAlchemy + pytest',
+    rules: [
+      'languages/python.mdc',
+      'frameworks/fastapi.mdc',
+      'tools/pydantic.mdc',
+      'tools/sqlalchemy.mdc',
+      'tools/pytest.mdc',
+      'practices/api-design.mdc',
+      'practices/error-handling.mdc',
+      'practices/clean-code.mdc',
+    ],
+  },
+  'sveltekit': {
+    name: 'SvelteKit Full Stack',
+    description: 'SvelteKit + Svelte + Tailwind + Prisma + TypeScript',
+    rules: [
+      'languages/typescript.mdc',
+      'frameworks/sveltekit.mdc',
+      'frameworks/svelte.mdc',
+      'frameworks/tailwind-css.mdc',
+      'tools/prisma.mdc',
+      'practices/clean-code.mdc',
+      'practices/error-handling.mdc',
+    ],
+  },
+  'rails': {
+    name: 'Ruby on Rails',
+    description: 'Rails + Ruby + PostgreSQL + Testing',
+    rules: [
+      'languages/ruby.mdc',
+      'frameworks/rails.mdc',
+      'tools/postgresql.mdc',
+      'practices/testing.mdc',
+      'practices/api-design.mdc',
+      'practices/database-migrations.mdc',
+      'practices/clean-code.mdc',
+    ],
+  },
+  'nextjs': {
+    name: 'Next.js Full Stack',
+    description: 'Next.js + React + TypeScript + Tailwind + Prisma',
+    rules: [
+      'languages/typescript.mdc',
+      'frameworks/nextjs.mdc',
+      'frameworks/react.mdc',
+      'frameworks/tailwind-css.mdc',
+      'tools/prisma.mdc',
+      'practices/clean-code.mdc',
+      'practices/performance.mdc',
+      'practices/error-handling.mdc',
+    ],
+  },
+  'django': {
+    name: 'Django Full Stack',
+    description: 'Django + Python + PostgreSQL + pytest',
+    rules: [
+      'languages/python.mdc',
+      'frameworks/django.mdc',
+      'tools/postgresql.mdc',
+      'tools/pytest.mdc',
+      'practices/api-design.mdc',
+      'practices/database-migrations.mdc',
+      'practices/security.mdc',
+      'practices/clean-code.mdc',
+    ],
+  },
+};
+
 const SKILLS_API = 'https://skills.sh/api/search';
 
 function searchSkillsAPI(query, limit) {
@@ -497,4 +656,43 @@ async function suggestSkills(detected) {
   return allResults.slice(0, 10);
 }
 
-module.exports = { generateRules, suggestSkills };
+function listPresets() {
+  return STACK_PRESETS;
+}
+
+async function generateFromPreset(cwd, presetName) {
+  const preset = STACK_PRESETS[presetName];
+  if (!preset) {
+    throw new Error(`Unknown preset: ${presetName}`);
+  }
+
+  const rulesDir = path.join(cwd, '.cursor', 'rules');
+  const created = [];
+  const skipped = [];
+  const failed = [];
+
+  fs.mkdirSync(rulesDir, { recursive: true });
+
+  for (const rulePath of preset.rules) {
+    const filename = path.basename(rulePath);
+    const destPath = path.join(rulesDir, filename);
+
+    if (fs.existsSync(destPath)) {
+      skipped.push({ file: filename, rule: rulePath });
+      continue;
+    }
+
+    try {
+      const url = BASE_URL + rulePath;
+      const content = await fetchFile(url);
+      fs.writeFileSync(destPath, content, 'utf8');
+      created.push({ file: filename, rule: rulePath });
+    } catch (err) {
+      failed.push({ file: filename, rule: rulePath, error: err.message });
+    }
+  }
+
+  return { preset: presetName, presetInfo: preset, created, skipped, failed };
+}
+
+module.exports = { generateRules, suggestSkills, listPresets, generateFromPreset };