cursor-lint 0.11.1 → 0.13.0

package/README.md

@@ -3,7 +3,7 @@
 [![npm](https://img.shields.io/npm/dw/cursor-lint)](https://www.npmjs.com/package/cursor-lint)
 [![npm version](https://img.shields.io/npm/v/cursor-lint)](https://www.npmjs.com/package/cursor-lint)
 
-Lint your [Cursor](https://cursor.com) rules. Catch common mistakes before they silently break your workflow.
+Lint your [Cursor](https://cursor.com) rules. Find problems before they silently break your output.
 
 ![cursor-lint demo](demo.png)
 
@@ -133,6 +133,10 @@ Made by [nedcodes](https://dev.to/nedcodes) · [Free rules collection](https://g
 
 ---
 
+## Stay Updated
+
+Get experiment results and Cursor findings in your inbox: [subscribe](https://buttondown.com/nedcodes)
+
 ## Related
 
 - [cursorrules-collection](https://github.com/nedcodes-ok/cursorrules-collection) — 104 free .mdc rules

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-lint",
-  "version": "0.11.1",
+  "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,15 +5,16 @@ 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.11.0';
+const VERSION = '0.13.0';
 
 const RED = '\x1b[31m';
 const YELLOW = '\x1b[33m';
 const GREEN = '\x1b[32m';
 const CYAN = '\x1b[36m';
+const BLUE = '\x1b[34m';
 const DIM = '\x1b[2m';
 const RESET = '\x1b[0m';
 
@@ -33,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
 
@@ -42,6 +45,14 @@ ${YELLOW}What it checks (default):${RESET}
   • Agent skill files (SKILL.md in .claude/skills/, skills/)
   • Vague rules that won't change AI behavior
   • YAML syntax errors
+  • Rule length (token waste detection)
+  • Missing code examples in rules
+  • Empty rule bodies, URL-only rules
+  • Description quality (too short/long)
+  • Glob pattern issues (too broad, spaces, missing extensions)
+  • Excessive rule count (>20 files)
+  • Duplicate/near-duplicate rules across files
+  • Conflicting directives between rules
 
 ${YELLOW}What --verify checks:${RESET}
   • Scans code files matching rule globs
@@ -199,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}`);
@@ -241,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) {
@@ -397,6 +487,7 @@ async function main() {
 
     let totalErrors = 0;
     let totalWarnings = 0;
+    let totalInfo = 0;
     let totalPassed = 0;
 
     for (const result of results) {
@@ -408,7 +499,11 @@ async function main() {
         totalPassed++;
       } else {
         for (const issue of result.issues) {
-          const icon = issue.severity === 'error' ? `${RED}✗${RESET}` : `${YELLOW}⚠${RESET}`;
+          let icon;
+          if (issue.severity === 'error') icon = `${RED}✗${RESET}`;
+          else if (issue.severity === 'info') icon = `${BLUE}ℹ${RESET}`;
+          else icon = `${YELLOW}⚠${RESET}`;
+          
           const lineInfo = issue.line ? ` ${DIM}(line ${issue.line})${RESET}` : '';
           console.log(`  ${icon} ${issue.message}${lineInfo}`);
           if (issue.hint) {
@@ -417,9 +512,11 @@ async function main() {
         }
         const errors = result.issues.filter(i => i.severity === 'error').length;
         const warnings = result.issues.filter(i => i.severity === 'warning').length;
+        const infos = result.issues.filter(i => i.severity === 'info').length;
         totalErrors += errors;
         totalWarnings += warnings;
-        if (errors === 0 && warnings === 0) totalPassed++;
+        totalInfo += infos;
+        if (errors === 0 && warnings === 0 && infos === 0) totalPassed++;
       }
       console.log();
     }
@@ -428,6 +525,7 @@ async function main() {
     const parts = [];
     if (totalErrors > 0) parts.push(`${RED}${totalErrors} error${totalErrors !== 1 ? 's' : ''}${RESET}`);
     if (totalWarnings > 0) parts.push(`${YELLOW}${totalWarnings} warning${totalWarnings !== 1 ? 's' : ''}${RESET}`);
+    if (totalInfo > 0) parts.push(`${BLUE}${totalInfo} info${RESET}`);
     if (totalPassed > 0) parts.push(`${GREEN}${totalPassed} passed${RESET}`);
     console.log(parts.join(', ') + '\n');
 

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 };

package/src/index.js

@@ -59,6 +59,37 @@ function parseFrontmatter(content) {
   }
 }
 
+// Helper: Get body content after frontmatter
+function getBody(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n?/);
+  if (!match) return content;
+  return content.slice(match[0].length);
+}
+
+// Helper: Calculate similarity between two texts using Jaccard similarity
+function similarity(textA, textB) {
+  const normalize = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
+  const normA = normalize(textA);
+  const normB = normalize(textB);
+  
+  // Check if one is substring of the other
+  if (normA.includes(normB) || normB.includes(normA)) {
+    return 1.0;
+  }
+  
+  // Word-based Jaccard similarity
+  const wordsA = new Set(normA.split(/\s+/));
+  const wordsB = new Set(normB.split(/\s+/));
+  
+  if (wordsA.size === 0 && wordsB.size === 0) return 1.0;
+  if (wordsA.size === 0 || wordsB.size === 0) return 0.0;
+  
+  const intersection = new Set([...wordsA].filter(w => wordsB.has(w)));
+  const union = new Set([...wordsA, ...wordsB]);
+  
+  return intersection.size / union.size;
+}
+
 async function lintMdcFile(filePath) {
   const content = fs.readFileSync(filePath, 'utf-8');
   const issues = [];
@@ -91,6 +122,112 @@ async function lintMdcFile(filePath) {
     }
   }
 
+  // Get body content for additional checks
+  const body = getBody(content);
+
+  // 1. Rule too long
+  if (body.length > 2000) {
+    issues.push({
+      severity: 'warning',
+      message: 'Rule body is very long (>2000 chars, ~500+ tokens)',
+      hint: 'Shorter, specific rules outperform long generic ones. Consider splitting into focused rules.',
+    });
+  }
+
+  // 2. No examples
+  const hasCodeBlocks = /```/.test(body) || /\n {4,}\S/.test(body);
+  if (body.length > 200 && !hasCodeBlocks) {
+    issues.push({
+      severity: 'warning',
+      message: 'Rule has no code examples',
+      hint: 'Rules with examples get followed more reliably by the AI model.',
+    });
+  }
+
+  // 3. Empty rule body
+  if (fm.found && body.trim().length === 0) {
+    issues.push({
+      severity: 'error',
+      message: 'Rule file has frontmatter but no instructions',
+      hint: 'Add rule instructions after the --- frontmatter block.',
+    });
+  }
+
+  // 4. Description too short
+  if (fm.data && fm.data.description && fm.data.description.length < 10) {
+    issues.push({
+      severity: 'warning',
+      message: 'Description is very short (<10 chars)',
+      hint: 'A descriptive description helps Cursor decide when to apply this rule.',
+    });
+  }
+
+  // 5. Description too long
+  if (fm.data && fm.data.description && fm.data.description.length > 200) {
+    issues.push({
+      severity: 'warning',
+      message: 'Description is very long (>200 chars)',
+      hint: 'Keep descriptions concise. Put detailed instructions in the rule body, not the description.',
+    });
+  }
+
+  // 6. Glob pattern issues
+  if (fm.data && fm.data.globs) {
+    const globs = parseGlobs(fm.data.globs);
+    for (const glob of globs) {
+      // Overly broad glob
+      if (glob === '*' || glob === '**') {
+        issues.push({
+          severity: 'warning',
+          message: 'Overly broad glob pattern',
+          hint: 'This matches everything. Consider using more specific patterns or just alwaysApply: true.',
+        });
+      }
+      // Glob contains spaces
+      if (glob.includes(' ') && !glob.includes('"') && !glob.includes("'")) {
+        issues.push({
+          severity: 'warning',
+          message: 'Glob pattern contains spaces',
+          hint: 'Glob patterns with spaces may not match correctly.',
+        });
+      }
+      // Glob is *.
+      if (glob === '*.') {
+        issues.push({
+          severity: 'warning',
+          message: 'Glob pattern has no file extension after dot',
+        });
+      }
+    }
+  }
+
+  // 7. alwaysApply + globs info
+  if (fm.data && fm.data.alwaysApply === true && fm.data.globs) {
+    const globs = parseGlobs(fm.data.globs);
+    if (globs.length > 0) {
+      issues.push({
+        severity: 'info',
+        message: 'alwaysApply is true with globs set',
+        hint: 'When alwaysApply is true, globs serve as a hint to the model but don\'t filter. This is fine if intentional.',
+      });
+    }
+  }
+
+  // 8. Rule body is just a URL
+  const bodyTrimmed = body.trim();
+  const urlMatch = bodyTrimmed.match(/^https?:\/\//);
+  if (urlMatch) {
+    const lines = bodyTrimmed.split('\n').filter(line => line.trim().length > 0);
+    const nonUrlLines = lines.filter(line => !line.trim().match(/^https?:\/\//));
+    if (nonUrlLines.length < 2) {
+      issues.push({
+        severity: 'warning',
+        message: 'Rule body appears to be just a URL',
+        hint: 'Cursor cannot follow URLs. Put the actual instructions in the rule body.',
+      });
+    }
+  }
+
   return { file: filePath, issues };
 }
 
@@ -249,6 +386,54 @@ async function lintProject(dir) {
     });
   }
 
+  // 9. Excessive rules count & 10. Duplicate rule content
+  const rulesDirPath = path.join(dir, '.cursor', 'rules');
+  if (fs.existsSync(rulesDirPath) && fs.statSync(rulesDirPath).isDirectory()) {
+    const mdcFiles = fs.readdirSync(rulesDirPath).filter(f => f.endsWith('.mdc'));
+    
+    if (mdcFiles.length > 20) {
+      results.push({
+        file: rulesDirPath,
+        issues: [{
+          severity: 'warning',
+          message: `Project has ${mdcFiles.length} rule files`,
+          hint: 'More rules means more tokens consumed per request. Consider consolidating related rules.',
+        }],
+      });
+    }
+
+    // 10. Duplicate rule content
+    if (mdcFiles.length > 1) {
+      const parsed = [];
+      for (const file of mdcFiles) {
+        const filePath = path.join(rulesDirPath, file);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const body = getBody(content);
+        parsed.push({ file, filePath, body });
+      }
+
+      // Compare each pair
+      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];
+          const sim = similarity(a.body, b.body);
+          
+          if (sim > 0.8) {
+            results.push({
+              file: rulesDirPath,
+              issues: [{
+                severity: 'warning',
+                message: `Possible duplicate rules: ${a.file} and ${b.file}`,
+                hint: 'These rules have very similar content. Consider merging them.',
+              }],
+            });
+          }
+        }
+      }
+    }
+  }
+
   return results;
 }