cursor-lint 0.4.1 → 0.6.0

package/package.json

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

package/src/cli.js

@@ -5,8 +5,9 @@ const { lintProject } = require('./index');
 const { verifyProject } = require('./verify');
 const { initProject } = require('./init');
 const { fixProject } = require('./fix');
+const { generateRules } = require('./generate');
 
-const VERSION = '0.4.1';
+const VERSION = '0.6.0';
 
 const RED = '\x1b[31m';
 const YELLOW = '\x1b[33m';
@@ -30,6 +31,7 @@ ${YELLOW}Options:${RESET}
   --verify       Check if code follows rules with verify: blocks
   --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
 
 ${YELLOW}What it checks (default):${RESET}
   • .cursorrules files (warns about agent mode compatibility)
@@ -61,6 +63,7 @@ ${YELLOW}Examples:${RESET}
   npx cursor-lint              # Lint rule files
   npx cursor-lint --verify     # Check code against rules
   npx cursor-lint --init       # Generate starter rules for your project
+  npx cursor-lint --generate   # Download community rules for your stack
 
 ${YELLOW}More info:${RESET}
   https://github.com/cursorrulespacks/cursor-lint
@@ -84,8 +87,50 @@ async function main() {
   const isVerify = args.includes('--verify');
   const isInit = args.includes('--init');
   const isFix = args.includes('--fix');
+  const isGenerate = args.includes('--generate');
 
-  if (isFix) {
+  if (isGenerate) {
+    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`);
+    } else {
+      console.log(`${YELLOW}No recognized stack detected.${RESET}`);
+      console.log(`${DIM}Supports: package.json, tsconfig.json, requirements.txt, Cargo.toml, go.mod, Dockerfile${RESET}\n`);
+      process.exit(0);
+    }
+
+    if (results.created.length > 0) {
+      console.log(`${GREEN}Downloaded:${RESET}`);
+      for (const r of results.created) {
+        console.log(`  ${GREEN}✓${RESET} .cursor/rules/${r.file} ${DIM}(${r.stack})${RESET}`);
+      }
+    }
+
+    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);
+
+  } else if (isFix) {
     console.log(`\n🔧 cursor-lint v${VERSION} --fix\n`);
     console.log(`Scanning ${cwd} for fixable issues...\n`);
 

package/src/generate.js

@@ -0,0 +1,156 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const BASE_URL = 'https://raw.githubusercontent.com/cursorrulespacks/cursorrules-collection/main/rules-mdc/';
+
+const PKG_DEP_MAP = {
+  'react': 'frameworks/react.mdc',
+  'next': 'frameworks/nextjs.mdc',
+  'vue': 'frameworks/vue.mdc',
+  'svelte': 'frameworks/svelte.mdc',
+  'express': 'frameworks/express.mdc',
+  '@nestjs/core': 'frameworks/nestjs.mdc',
+  'prisma': 'tools/prisma.mdc',
+  'drizzle-orm': 'tools/drizzle.mdc',
+};
+
+const REQ_DEP_MAP = {
+  'django': 'frameworks/django.mdc',
+  'fastapi': 'frameworks/fastapi.mdc',
+  'flask': 'frameworks/flask.mdc',
+  'pydantic': 'tools/pydantic.mdc',
+  'sqlalchemy': 'tools/sqlalchemy.mdc',
+  'pytest': 'tools/pytest.mdc',
+};
+
+function fetchFile(url) {
+  return new Promise((resolve, reject) => {
+    const get = (u) => {
+      https.get(u, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          get(res.headers.location);
+          return;
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode} for ${u}`));
+          res.resume();
+          return;
+        }
+        let data = '';
+        res.on('data', (c) => data += c);
+        res.on('end', () => resolve(data));
+        res.on('error', reject);
+      }).on('error', reject);
+    };
+    get(url);
+  });
+}
+
+function detectStack(cwd) {
+  const detected = [];
+  const rules = new Map(); // rulePath -> stackName
+
+  // package.json
+  const pkgPath = path.join(cwd, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      for (const [dep, rule] of Object.entries(PKG_DEP_MAP)) {
+        if (allDeps[dep]) {
+          detected.push(dep);
+          rules.set(rule, dep);
+        }
+      }
+    } catch {}
+  }
+
+  // tsconfig.json
+  if (fs.existsSync(path.join(cwd, 'tsconfig.json'))) {
+    detected.push('TypeScript');
+    rules.set('languages/typescript.mdc', 'TypeScript');
+  }
+
+  // Python
+  const reqPath = path.join(cwd, 'requirements.txt');
+  const hasPy = fs.existsSync(reqPath) || fs.readdirSync(cwd).some(f => f.endsWith('.py'));
+  if (hasPy) {
+    detected.push('Python');
+    rules.set('languages/python.mdc', 'Python');
+  }
+  if (fs.existsSync(reqPath)) {
+    try {
+      const req = fs.readFileSync(reqPath, 'utf8').toLowerCase();
+      for (const [dep, rule] of Object.entries(REQ_DEP_MAP)) {
+        if (req.includes(dep)) {
+          detected.push(dep);
+          rules.set(rule, dep);
+        }
+      }
+    } catch {}
+  }
+
+  // Cargo.toml
+  if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) {
+    detected.push('Rust');
+    rules.set('languages/rust.mdc', 'Rust');
+  }
+
+  // go.mod
+  if (fs.existsSync(path.join(cwd, 'go.mod'))) {
+    detected.push('Go');
+    rules.set('languages/go.mdc', 'Go');
+  }
+
+  // Dockerfile
+  if (fs.existsSync(path.join(cwd, 'Dockerfile'))) {
+    detected.push('Docker');
+    rules.set('tools/docker.mdc', 'Docker');
+  }
+
+  // CI/CD
+  if (fs.existsSync(path.join(cwd, '.github', 'workflows'))) {
+    detected.push('CI/CD');
+    rules.set('tools/ci-cd.mdc', 'CI/CD');
+  }
+
+  return { detected, rules };
+}
+
+async function generateRules(cwd) {
+  const { detected, rules } = detectStack(cwd);
+  const rulesDir = path.join(cwd, '.cursor', 'rules');
+  const created = [];
+  const skipped = [];
+  const failed = [];
+
+  if (rules.size === 0) {
+    return { detected, created, skipped, failed };
+  }
+
+  fs.mkdirSync(rulesDir, { recursive: true });
+
+  for (const [rulePath, stackName] of rules) {
+    const filename = path.basename(rulePath);
+    const destPath = path.join(rulesDir, filename);
+
+    if (fs.existsSync(destPath)) {
+      skipped.push({ file: filename, stack: stackName });
+      continue;
+    }
+
+    try {
+      const url = BASE_URL + rulePath;
+      const content = await fetchFile(url);
+      fs.writeFileSync(destPath, content, 'utf8');
+      created.push({ file: filename, stack: stackName });
+    } catch (err) {
+      failed.push({ file: filename, stack: stackName, error: err.message });
+    }
+  }
+
+  return { detected, created, skipped, failed };
+}
+
+module.exports = { generateRules };

package/src/index.js

@@ -76,7 +76,7 @@ async function lintMdcFile(filePath) {
     if (!fm.data.description) {
       issues.push({ severity: 'warning', message: 'Missing description in frontmatter', hint: 'Add a description so Cursor knows when to apply this rule' });
     }
-    if (fm.data.globs && typeof fm.data.globs === 'string' && fm.data.globs.includes(',')) {
+    if (fm.data.globs && typeof fm.data.globs === 'string' && fm.data.globs.includes(',') && !fm.data.globs.trim().startsWith('[')) {
       issues.push({ severity: 'error', message: 'Globs should be YAML array, not comma-separated string', hint: 'Use globs:\\n  - "*.ts"\\n  - "*.tsx"' });
     }
   }
@@ -141,7 +141,146 @@ async function lintProject(dir) {
     });
   }
 
+  // Conflict detection across .mdc files
+  const conflicts = detectConflicts(dir);
+  if (conflicts.length > 0) {
+    results.push({
+      file: path.join(dir, '.cursor/rules/'),
+      issues: conflicts,
+    });
+  }
+
   return results;
 }
 
-module.exports = { lintProject, lintMdcFile, lintCursorrules };
+function parseGlobs(globVal) {
+  if (!globVal) return [];
+  if (typeof globVal === 'string') {
+    // Handle both YAML array syntax and comma-separated
+    const trimmed = globVal.trim();
+    if (trimmed.startsWith('[')) {
+      // ["*.ts", "*.tsx"] format
+      return trimmed.slice(1, -1).split(',').map(g => g.trim().replace(/^["']|["']$/g, '')).filter(Boolean);
+    }
+    return trimmed.split(',').map(g => g.trim().replace(/^["']|["']$/g, '')).filter(Boolean);
+  }
+  if (Array.isArray(globVal)) return globVal;
+  return [];
+}
+
+function globsOverlap(globsA, globsB) {
+  // If either has no globs (alwaysApply), they overlap with everything
+  if (globsA.length === 0 || globsB.length === 0) return true;
+
+  for (const a of globsA) {
+    for (const b of globsB) {
+      // Exact match
+      if (a === b) return true;
+      // Both are wildcards covering same extension
+      const extA = a.match(/^\*\.(\w+)$/);
+      const extB = b.match(/^\*\.(\w+)$/);
+      if (extA && extB && extA[1] === extB[1]) return true;
+      // One is a superset pattern like **/*.ts
+      if (a.includes('**') || b.includes('**')) {
+        const extA2 = a.match(/\*\.(\w+)$/);
+        const extB2 = b.match(/\*\.(\w+)$/);
+        if (extA2 && extB2 && extA2[1] === extB2[1]) return true;
+      }
+    }
+  }
+  return false;
+}
+
+function extractDirectives(content) {
+  // Extract actionable instructions from rule body (after frontmatter)
+  const body = content.replace(/^---[\s\S]*?---\n?/, '').toLowerCase();
+  const directives = [];
+
+  // Look for contradictory patterns: "always use X" vs "never use X"
+  const alwaysMatch = body.match(/always\s+use\s+(\S+)/g) || [];
+  const neverMatch = body.match(/never\s+use\s+(\S+)/g) || [];
+  const preferMatch = body.match(/prefer\s+(\S+)/g) || [];
+  const avoidMatch = body.match(/avoid\s+(\S+)/g) || [];
+  const doNotMatch = body.match(/do\s+not\s+use\s+(\S+)/g) || [];
+
+  for (const m of alwaysMatch) directives.push({ type: 'require', subject: m.replace(/^always\s+use\s+/, '') });
+  for (const m of neverMatch) directives.push({ type: 'forbid', subject: m.replace(/^never\s+use\s+/, '') });
+  for (const m of preferMatch) directives.push({ type: 'prefer', subject: m.replace(/^prefer\s+/, '') });
+  for (const m of avoidMatch) directives.push({ type: 'avoid', subject: m.replace(/^avoid\s+/, '') });
+  for (const m of doNotMatch) directives.push({ type: 'forbid', subject: m.replace(/^do\s+not\s+use\s+/, '') });
+
+  return directives;
+}
+
+function detectConflicts(dir) {
+  const rulesDir = path.join(dir, '.cursor', 'rules');
+  if (!fs.existsSync(rulesDir) || !fs.statSync(rulesDir).isDirectory()) return [];
+
+  const files = fs.readdirSync(rulesDir).filter(f => f.endsWith('.mdc'));
+  if (files.length < 2) return [];
+
+  const parsed = [];
+  for (const file of files) {
+    const filePath = path.join(rulesDir, file);
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const fm = parseFrontmatter(content);
+    const globs = fm.data ? parseGlobs(fm.data.globs) : [];
+    const alwaysApply = fm.data && fm.data.alwaysApply;
+    const directives = extractDirectives(content);
+    parsed.push({ file, filePath, globs, alwaysApply, directives, content });
+  }
+
+  const issues = [];
+
+  // Check for duplicate alwaysApply rules with overlapping globs
+  for (let i = 0; i < parsed.length; i++) {
+    for (let j = i + 1; j < parsed.length; j++) {
+      const a = parsed[i];
+      const b = parsed[j];
+
+      // Check glob overlap
+      const aGlobs = a.alwaysApply && a.globs.length === 0 ? [] : a.globs;
+      const bGlobs = b.alwaysApply && b.globs.length === 0 ? [] : b.globs;
+      const overlap = globsOverlap(aGlobs, bGlobs);
+
+      if (!overlap) continue;
+
+      // Check for contradictory directives
+      for (const dA of a.directives) {
+        for (const dB of b.directives) {
+          if (dA.subject !== dB.subject) continue;
+
+          const contradicts =
+            (dA.type === 'require' && (dB.type === 'forbid' || dB.type === 'avoid')) ||
+            (dA.type === 'forbid' && (dB.type === 'require' || dB.type === 'prefer')) ||
+            (dA.type === 'prefer' && dB.type === 'forbid') ||
+            (dA.type === 'avoid' && dB.type === 'require');
+
+          if (contradicts) {
+            issues.push({
+              severity: 'error',
+              message: `Conflicting rules: ${a.file} says "${dA.type} ${dA.subject}" but ${b.file} says "${dB.type} ${dB.subject}"`,
+              hint: 'Conflicting directives confuse the model. Remove or reconcile one of these rules.',
+            });
+          }
+        }
+      }
+
+      // Check for duplicate glob coverage (both alwaysApply targeting same files)
+      if (a.alwaysApply && b.alwaysApply && a.globs.length > 0 && b.globs.length > 0) {
+        const sharedGlobs = a.globs.filter(g => b.globs.includes(g));
+        if (sharedGlobs.length > 0) {
+          issues.push({
+            severity: 'warning',
+            message: `Overlapping globs: ${a.file} and ${b.file} both target ${sharedGlobs.join(', ')}`,
+            hint: 'Multiple rules targeting the same files may cause unpredictable behavior. Consider merging them.',
+          });
+        }
+      }
+    }
+  }
+
+  return issues;
+}
+
+module.exports = { lintProject, lintMdcFile, lintCursorrules, detectConflicts };