cursor-lint 0.8.0 → 0.9.0

package/package.json

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

package/src/cli.js

@@ -8,7 +8,7 @@ const { fixProject } = require('./fix');
 const { generateRules } = require('./generate');
 const { checkVersions, checkRuleVersionMismatches } = require('./versions');
 
-const VERSION = '0.8.0';
+const VERSION = '0.9.0';
 
 const RED = '\x1b[31m';
 const YELLOW = '\x1b[33m';
@@ -207,20 +207,35 @@ async function main() {
       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`);
+      console.log(`${DIM}Supports: package.json, tsconfig.json, requirements.txt, pyproject.toml,${RESET}`);
+      console.log(`${DIM}Cargo.toml, go.mod, Gemfile, composer.json, pom.xml, build.gradle,${RESET}`);
+      console.log(`${DIM}Dockerfile, pubspec.yaml, mix.exs, build.sbt, *.csproj, and more${RESET}\n`);
       process.exit(0);
     }
 
-    if (results.created.length > 0) {
-      console.log(`${GREEN}Downloaded:${RESET}`);
-      for (const r of results.created) {
+    const stackCreated = results.created.filter(r => !r.stack.startsWith('best-practice:'));
+    const practiceCreated = results.created.filter(r => r.stack.startsWith('best-practice:'));
+    const stackSkipped = results.skipped.filter(r => !r.stack.startsWith('best-practice:'));
+    const practiceSkipped = results.skipped.filter(r => r.stack.startsWith('best-practice:'));
+
+    if (stackCreated.length > 0) {
+      console.log(`${GREEN}Downloaded (stack rules):${RESET}`);
+      for (const r of stackCreated) {
         console.log(`  ${GREEN}✓${RESET} .cursor/rules/${r.file} ${DIM}(${r.stack})${RESET}`);
       }
     }
 
-    if (results.skipped.length > 0) {
+    if (practiceCreated.length > 0) {
+      console.log(`\n${GREEN}Downloaded (best practices):${RESET}`);
+      for (const r of practiceCreated) {
+        const label = r.stack.replace('best-practice: ', '');
+        console.log(`  ${GREEN}✓${RESET} .cursor/rules/${r.file} ${DIM}(${label})${RESET}`);
+      }
+    }
+
+    if (stackSkipped.length + practiceSkipped.length > 0) {
       console.log(`\n${YELLOW}Skipped (already exist):${RESET}`);
-      for (const r of results.skipped) {
+      for (const r of [...stackSkipped, ...practiceSkipped]) {
         console.log(`  ${YELLOW}⚠${RESET} .cursor/rules/${r.file}`);
       }
     }

package/src/generate.js

@@ -4,24 +4,99 @@ const https = require('https');
 
 const BASE_URL = 'https://raw.githubusercontent.com/cursorrulespacks/cursorrules-collection/main/rules-mdc/';
 
+// package.json dependencies → rule files
 const PKG_DEP_MAP = {
+  // Frameworks
   'react': 'frameworks/react.mdc',
   'next': 'frameworks/nextjs.mdc',
   'vue': 'frameworks/vue.mdc',
+  'nuxt': 'frameworks/nuxt.mdc',
   'svelte': 'frameworks/svelte.mdc',
+  '@sveltejs/kit': 'frameworks/sveltekit.mdc',
   'express': 'frameworks/express.mdc',
   '@nestjs/core': 'frameworks/nestjs.mdc',
+  '@angular/core': 'frameworks/angular.mdc',
+  'astro': 'frameworks/astro.mdc',
+  'gatsby': 'frameworks/gatsby.mdc',
+  'remix': 'frameworks/remix.mdc',
+  'solid-js': 'frameworks/solid-js.mdc',
+  'hono': 'frameworks/hono.mdc',
+  'htmx.org': 'frameworks/htmx.mdc',
+  'electron': 'frameworks/electron.mdc',
+  '@tauri-apps/api': 'frameworks/tauri.mdc',
+  'expo': 'frameworks/expo.mdc',
+  'swr': 'frameworks/swr.mdc',
+  '@tanstack/react-query': 'frameworks/tanstack-query.mdc',
+  'zod': 'frameworks/zod.mdc',
+  'zustand': 'frameworks/zustand.mdc',
+  '@t3-oss/env-nextjs': 'frameworks/t3-stack.mdc',
+  'tailwindcss': 'frameworks/tailwind-css.mdc',
+
+  // Tools
   'prisma': 'tools/prisma.mdc',
   'drizzle-orm': 'tools/drizzle.mdc',
+  '@trpc/server': 'tools/trpc.mdc',
+  'graphql': 'tools/graphql.mdc',
+  '@supabase/supabase-js': 'tools/supabase.mdc',
+  'firebase': 'tools/firebase.mdc',
+  'convex': 'tools/convex.mdc',
+  '@clerk/nextjs': 'tools/clerk.mdc',
+  'next-auth': 'tools/nextauth.mdc',
+  'stripe': 'tools/stripe.mdc',
+  '@langchain/core': 'tools/langchain.mdc',
+  'mongodb': 'tools/mongodb.mdc',
+  'redis': 'tools/redis.mdc',
+  'jest': 'tools/jest.mdc',
+  'vitest': 'tools/vitest.mdc',
+  'cypress': 'tools/cypress.mdc',
+  '@playwright/test': 'tools/playwright.mdc',
+  '@storybook/react': 'tools/storybook.mdc',
+  'turborepo': 'tools/turborepo.mdc',
+  'bun': 'tools/bun.mdc',
 };
 
-const REQ_DEP_MAP = {
+// Python requirements.txt / pyproject.toml → rule files
+const PY_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',
+  'langchain': 'tools/langchain.mdc',
+  'ruff': 'tools/ruff.mdc',
+};
+
+// Gemfile → rule files
+const RUBY_DEP_MAP = {
+  'rails': 'frameworks/rails.mdc',
+};
+
+// composer.json → rule files
+const PHP_DEP_MAP = {
+  'laravel/framework': 'frameworks/laravel.mdc',
+};
+
+// build.gradle / pom.xml → rule files
+const JVM_DEP_MAP = {
+  'spring-boot': 'frameworks/spring-boot.mdc',
+};
+
+// Best practices auto-included when certain conditions are met
+const PRACTICE_TRIGGERS = {
+  // Always suggest these for any project with >3 detected deps
+  'practices/clean-code.mdc': { minDeps: 3, label: 'clean-code' },
+  'practices/error-handling.mdc': { minDeps: 3, label: 'error-handling' },
+  'practices/git-workflow.mdc': { files: ['.git'], label: 'git-workflow' },
+  'practices/testing.mdc': { deps: ['jest', 'vitest', 'cypress', '@playwright/test', 'pytest', 'mocha', 'ava'], label: 'testing' },
+  'practices/security.mdc': { minDeps: 5, label: 'security' },
+  'practices/documentation.mdc': { files: ['README.md'], label: 'documentation' },
+  'practices/api-design.mdc': { deps: ['express', '@nestjs/core', 'fastapi', 'flask', 'django', 'hono', '@trpc/server', 'graphql'], label: 'api-design' },
+  'practices/performance.mdc': { deps: ['react', 'next', 'vue', 'nuxt', '@angular/core', 'svelte'], label: 'performance' },
+  'practices/database-migrations.mdc': { deps: ['prisma', 'drizzle-orm', 'sqlalchemy', 'django'], label: 'database-migrations' },
+  'practices/monorepo.mdc': { files: ['pnpm-workspace.yaml', 'lerna.json'], deps: ['turborepo'], label: 'monorepo' },
+  'practices/accessibility.mdc': { deps: ['react', 'next', 'vue', '@angular/core', 'svelte'], label: 'accessibility' },
+  'practices/logging.mdc': { deps: ['express', '@nestjs/core', 'fastapi', 'flask', 'django', 'hono'], label: 'logging' },
 };
 
 function fetchFile(url) {
@@ -47,74 +122,290 @@ function fetchFile(url) {
   });
 }
 
+function readPyDeps(cwd) {
+  const deps = [];
+
+  // requirements.txt
+  const reqPath = path.join(cwd, 'requirements.txt');
+  if (fs.existsSync(reqPath)) {
+    try {
+      const content = fs.readFileSync(reqPath, 'utf8').toLowerCase();
+      for (const dep of Object.keys(PY_DEP_MAP)) {
+        if (content.includes(dep)) deps.push(dep);
+      }
+    } catch {}
+  }
+
+  // pyproject.toml (rough match)
+  const pyprojectPath = path.join(cwd, 'pyproject.toml');
+  if (fs.existsSync(pyprojectPath)) {
+    try {
+      const content = fs.readFileSync(pyprojectPath, 'utf8').toLowerCase();
+      for (const dep of Object.keys(PY_DEP_MAP)) {
+        if (content.includes(dep)) deps.push(dep);
+      }
+    } catch {}
+  }
+
+  return [...new Set(deps)];
+}
+
+function readRubyDeps(cwd) {
+  const gemfilePath = path.join(cwd, 'Gemfile');
+  if (!fs.existsSync(gemfilePath)) return [];
+  try {
+    const content = fs.readFileSync(gemfilePath, 'utf8').toLowerCase();
+    return Object.keys(RUBY_DEP_MAP).filter(dep => content.includes(dep));
+  } catch { return []; }
+}
+
+function readPhpDeps(cwd) {
+  const composerPath = path.join(cwd, 'composer.json');
+  if (!fs.existsSync(composerPath)) return [];
+  try {
+    const pkg = JSON.parse(fs.readFileSync(composerPath, 'utf8'));
+    const allDeps = { ...pkg.require, ...pkg['require-dev'] };
+    return Object.keys(PHP_DEP_MAP).filter(dep => allDeps[dep]);
+  } catch { return []; }
+}
+
+function readJvmDeps(cwd) {
+  const deps = [];
+  for (const file of ['build.gradle', 'build.gradle.kts', 'pom.xml']) {
+    const p = path.join(cwd, file);
+    if (fs.existsSync(p)) {
+      try {
+        const content = fs.readFileSync(p, 'utf8').toLowerCase();
+        for (const dep of Object.keys(JVM_DEP_MAP)) {
+          if (content.includes(dep)) deps.push(dep);
+        }
+      } catch {}
+    }
+  }
+  return [...new Set(deps)];
+}
+
 function detectStack(cwd) {
   const detected = [];
   const rules = new Map(); // rulePath -> stackName
+  const allDetectedDeps = [];
 
   // package.json
   const pkgPath = path.join(cwd, 'package.json');
+  let pkgDeps = {};
   if (fs.existsSync(pkgPath)) {
     try {
       const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      pkgDeps = { ...pkg.dependencies, ...pkg.devDependencies };
       for (const [dep, rule] of Object.entries(PKG_DEP_MAP)) {
-        if (allDeps[dep]) {
+        if (pkgDeps[dep]) {
           detected.push(dep);
+          allDetectedDeps.push(dep);
           rules.set(rule, dep);
         }
       }
     } catch {}
   }
 
-  // tsconfig.json
+  // tsconfig.json → TypeScript
   if (fs.existsSync(path.join(cwd, 'tsconfig.json'))) {
     detected.push('TypeScript');
     rules.set('languages/typescript.mdc', 'TypeScript');
   }
 
+  // JavaScript (package.json exists but no TS)
+  if (fs.existsSync(pkgPath) && !fs.existsSync(path.join(cwd, 'tsconfig.json'))) {
+    detected.push('JavaScript');
+    rules.set('languages/javascript.mdc', 'JavaScript');
+  }
+
   // Python
-  const reqPath = path.join(cwd, 'requirements.txt');
-  const hasPy = fs.existsSync(reqPath) || fs.readdirSync(cwd).some(f => f.endsWith('.py'));
-  if (hasPy) {
+  const hasPyFile = (() => { try { return fs.readdirSync(cwd).some(f => f.endsWith('.py')); } catch { return false; } })();
+  const hasPyProject = fs.existsSync(path.join(cwd, 'requirements.txt')) ||
+                       fs.existsSync(path.join(cwd, 'pyproject.toml')) ||
+                       fs.existsSync(path.join(cwd, 'setup.py')) ||
+                       hasPyFile;
+  if (hasPyProject) {
     detected.push('Python');
     rules.set('languages/python.mdc', 'Python');
+    const pyDeps = readPyDeps(cwd);
+    for (const dep of pyDeps) {
+      detected.push(dep);
+      allDetectedDeps.push(dep);
+      rules.set(PY_DEP_MAP[dep], dep);
+    }
   }
-  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 {}
+
+  // Ruby
+  if (fs.existsSync(path.join(cwd, 'Gemfile'))) {
+    detected.push('Ruby');
+    rules.set('languages/ruby.mdc', 'Ruby');
+    for (const dep of readRubyDeps(cwd)) {
+      detected.push(dep);
+      allDetectedDeps.push(dep);
+      rules.set(RUBY_DEP_MAP[dep], dep);
+    }
+  }
+
+  // PHP
+  if (fs.existsSync(path.join(cwd, 'composer.json'))) {
+    detected.push('PHP');
+    rules.set('languages/php.mdc', 'PHP');
+    for (const dep of readPhpDeps(cwd)) {
+      detected.push(dep);
+      allDetectedDeps.push(dep);
+      rules.set(PHP_DEP_MAP[dep], dep);
+    }
   }
 
-  // Cargo.toml
+  // Rust
   if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) {
     detected.push('Rust');
     rules.set('languages/rust.mdc', 'Rust');
   }
 
-  // go.mod
+  // Go
   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'))) {
+  // Java
+  if (fs.existsSync(path.join(cwd, 'pom.xml')) || fs.existsSync(path.join(cwd, 'build.gradle')) || fs.existsSync(path.join(cwd, 'build.gradle.kts'))) {
+    detected.push('Java');
+    rules.set('languages/java.mdc', 'Java');
+    for (const dep of readJvmDeps(cwd)) {
+      detected.push(dep);
+      allDetectedDeps.push(dep);
+      rules.set(JVM_DEP_MAP[dep], dep);
+    }
+  }
+
+  // Kotlin
+  if (fs.existsSync(path.join(cwd, 'build.gradle.kts'))) {
+    detected.push('Kotlin');
+    rules.set('languages/kotlin.mdc', 'Kotlin');
+  }
+
+  // Swift
+  if (fs.existsSync(path.join(cwd, 'Package.swift'))) {
+    detected.push('Swift');
+    rules.set('languages/swift.mdc', 'Swift');
+  }
+
+  // Elixir
+  if (fs.existsSync(path.join(cwd, 'mix.exs'))) {
+    detected.push('Elixir');
+    rules.set('languages/elixir.mdc', 'Elixir');
+  }
+
+  // Scala
+  if (fs.existsSync(path.join(cwd, 'build.sbt'))) {
+    detected.push('Scala');
+    rules.set('languages/scala.mdc', 'Scala');
+  }
+
+  // C#
+  const hasCsproj = (() => { try { return fs.readdirSync(cwd).some(f => f.endsWith('.csproj') || f.endsWith('.sln')); } catch { return false; } })();
+  if (hasCsproj) {
+    detected.push('C#');
+    rules.set('languages/csharp.mdc', 'C#');
+  }
+
+  // C++
+  if (fs.existsSync(path.join(cwd, 'CMakeLists.txt')) || fs.existsSync(path.join(cwd, 'Makefile'))) {
+    const hasCpp = (() => { try { return fs.readdirSync(cwd).some(f => /\.(cpp|cc|cxx|hpp|h)$/.test(f)); } catch { return false; } })();
+    if (hasCpp) {
+      detected.push('C++');
+      rules.set('languages/cpp.mdc', 'C++');
+    }
+  }
+
+  // Flutter (pubspec.yaml)
+  if (fs.existsSync(path.join(cwd, 'pubspec.yaml'))) {
+    detected.push('Flutter');
+    rules.set('frameworks/flutter.mdc', 'Flutter');
+  }
+
+  // Docker
+  if (fs.existsSync(path.join(cwd, 'Dockerfile')) || fs.existsSync(path.join(cwd, 'docker-compose.yml')) || fs.existsSync(path.join(cwd, 'docker-compose.yaml'))) {
     detected.push('Docker');
     rules.set('tools/docker.mdc', 'Docker');
   }
 
+  // Kubernetes
+  const k8sDir = path.join(cwd, 'k8s');
+  if (fs.existsSync(k8sDir) || fs.existsSync(path.join(cwd, 'kubernetes'))) {
+    detected.push('Kubernetes');
+    rules.set('tools/kubernetes.mdc', 'Kubernetes');
+  }
+
+  // Terraform
+  const hasTf = (() => { try { return fs.readdirSync(cwd).some(f => f.endsWith('.tf')); } catch { return false; } })();
+  if (hasTf) {
+    detected.push('Terraform');
+    rules.set('tools/terraform.mdc', 'Terraform');
+  }
+
+  // Deno
+  if (fs.existsSync(path.join(cwd, 'deno.json')) || fs.existsSync(path.join(cwd, 'deno.jsonc'))) {
+    detected.push('Deno');
+    rules.set('tools/deno.mdc', 'Deno');
+  }
+
   // CI/CD
-  if (fs.existsSync(path.join(cwd, '.github', 'workflows'))) {
+  if (fs.existsSync(path.join(cwd, '.github', 'workflows')) || fs.existsSync(path.join(cwd, '.gitlab-ci.yml'))) {
     detected.push('CI/CD');
     rules.set('tools/ci-cd.mdc', 'CI/CD');
   }
 
+  // Nginx
+  const hasNginx = (() => { try { return fs.readdirSync(cwd).some(f => f.includes('nginx')); } catch { return false; } })();
+  if (hasNginx) {
+    detected.push('Nginx');
+    rules.set('tools/nginx.mdc', 'Nginx');
+  }
+
+  // SQLite
+  if (pkgDeps['better-sqlite3'] || pkgDeps['sqlite3']) {
+    detected.push('SQLite');
+    allDetectedDeps.push('sqlite3');
+    rules.set('tools/sqlite.mdc', 'SQLite');
+  }
+
+  // PostgreSQL
+  if (pkgDeps['pg'] || pkgDeps['postgres']) {
+    detected.push('PostgreSQL');
+    allDetectedDeps.push('pg');
+    rules.set('tools/postgresql.mdc', 'PostgreSQL');
+  }
+
+  // AWS
+  if (pkgDeps['@aws-sdk/client-s3'] || pkgDeps['aws-sdk'] || fs.existsSync(path.join(cwd, 'serverless.yml')) || fs.existsSync(path.join(cwd, 'template.yaml'))) {
+    detected.push('AWS');
+    allDetectedDeps.push('aws-sdk');
+    rules.set('tools/aws.mdc', 'AWS');
+  }
+
+  // Best practices — auto-suggest based on project signals
+  for (const [rulePath, trigger] of Object.entries(PRACTICE_TRIGGERS)) {
+    let shouldInclude = false;
+
+    if (trigger.minDeps && allDetectedDeps.length >= trigger.minDeps) {
+      shouldInclude = true;
+    }
+    if (trigger.deps && trigger.deps.some(d => allDetectedDeps.includes(d) || pkgDeps[d])) {
+      shouldInclude = true;
+    }
+    if (trigger.files && trigger.files.some(f => fs.existsSync(path.join(cwd, f)))) {
+      shouldInclude = true;
+    }
+
+    if (shouldInclude) {
+      rules.set(rulePath, `best-practice: ${trigger.label}`);
+    }
+  }
+
   return { detected, rules };
 }