cursor-lint 0.1.0 → 0.2.0

package/package.json

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

package/src/cli.js

@@ -2,85 +2,173 @@
 
 const path = require('path');
 const { lintProject } = require('./index');
+const { verifyProject } = require('./verify');
 
-const args = process.argv.slice(2);
-
-if (args.includes('--help') || args.includes('-h')) {
-  console.log(`
-cursor-lint — Lint your Cursor rules
-
-Usage:
-  cursor-lint [directory]    Lint rules in directory (default: current dir)
-  cursor-lint --help         Show this help
-  cursor-lint --version      Show version
-
-Checks:
-  ✗ Missing alwaysApply: true in .mdc files
-  ✗ Bad YAML frontmatter / glob syntax
-  ⚠ .cursorrules ignored in agent mode
-  ⚠ Vague rules ("write clean code", etc.)
-  ⚠ Files too long for context window
-`);
-  process.exit(0);
-}
-
-if (args.includes('--version') || args.includes('-v')) {
-  const pkg = require('../package.json');
-  console.log(`cursor-lint v${pkg.version}`);
-  process.exit(0);
-}
-
-const dir = args[0] ? path.resolve(args[0]) : process.cwd();
+const VERSION = '0.2.0';
 
 const RED = '\x1b[31m';
 const YELLOW = '\x1b[33m';
 const GREEN = '\x1b[32m';
+const CYAN = '\x1b[36m';
 const DIM = '\x1b[2m';
 const RESET = '\x1b[0m';
 
+function showHelp() {
+  console.log(`
+${CYAN}cursor-lint${RESET} v${VERSION}
+
+Lint your Cursor rules and verify code compliance.
+
+${YELLOW}Usage:${RESET}
+  npx cursor-lint [options]
+
+${YELLOW}Options:${RESET}
+  --help, -h     Show this help message
+  --version, -v  Show version number
+  --verify       Check if code follows rules with verify: blocks
+
+${YELLOW}What it checks (default):${RESET}
+  • .cursorrules files (warns about agent mode compatibility)
+  • .cursor/rules/*.mdc files (frontmatter, alwaysApply, etc.)
+  • Vague rules that won't change AI behavior
+  • YAML syntax errors
+
+${YELLOW}What --verify checks:${RESET}
+  • Scans code files matching rule globs
+  • Checks for required patterns (pattern:, required:)
+  • Catches forbidden patterns (antipattern:, forbidden:)
+  • Reports violations with line numbers
+
+${YELLOW}verify: block syntax in .mdc frontmatter:${RESET}
+  ---
+  globs: ["*.ts", "*.tsx"]
+  verify:
+    - pattern: "^import.*from '@/"
+      message: "Use @/ alias for imports"
+    - antipattern: "console\\\\.log"
+      message: "Remove console.log"
+    - required: "use strict"
+      message: "Missing use strict"
+    - forbidden: "TODO"
+      message: "Resolve TODOs before commit"
+  ---
+
+${YELLOW}Examples:${RESET}
+  npx cursor-lint              # Lint rule files
+  npx cursor-lint --verify     # Check code against rules
+
+${YELLOW}More info:${RESET}
+  https://github.com/cursorrulespacks/cursor-lint
+`);
+}
+
 async function main() {
-  console.log(`\n🔍 cursor-lint v${require('../package.json').version}\n`);
-  console.log(`Scanning ${dir}...\n`);
-
-  const results = await lintProject(dir);
-
-  let totalErrors = 0;
-  let totalWarnings = 0;
-  let totalPassed = 0;
-
-  for (const result of results) {
-    const relPath = path.relative(dir, result.file) || result.file;
-    console.log(relPath);
-
-    if (result.issues.length === 0) {
-      console.log(`  ${GREEN}✓ All checks passed${RESET}`);
-      totalPassed++;
-    } else {
-      for (const issue of result.issues) {
-        const icon = issue.severity === 'error' ? `${RED}✗${RESET}` : `${YELLOW}⚠${RESET}`;
-        const lineInfo = issue.line ? ` ${DIM}(line ${issue.line})${RESET}` : '';
-        console.log(`  ${icon} ${issue.message}${lineInfo}`);
-        if (issue.hint) {
-          console.log(`    ${DIM}→ ${issue.hint}${RESET}`);
+  const args = process.argv.slice(2);
+  
+  if (args.includes('--help') || args.includes('-h')) {
+    showHelp();
+    process.exit(0);
+  }
+  
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+
+  const cwd = process.cwd();
+  const isVerify = args.includes('--verify');
+
+  if (isVerify) {
+    console.log(`\n🔍 cursor-lint v${VERSION} --verify\n`);
+    console.log(`Scanning ${cwd} for rule violations...\n`);
+
+    const results = await verifyProject(cwd);
+
+    if (results.stats.rulesWithVerify === 0) {
+      console.log(`${YELLOW}No rules with verify: blocks found.${RESET}`);
+      console.log(`${DIM}Add verify: blocks to your .mdc frontmatter to check code compliance.${RESET}`);
+      console.log(`${DIM}Run cursor-lint --help for syntax.${RESET}\n`);
+      process.exit(0);
+    }
+
+    console.log(`Found ${results.stats.rulesWithVerify} rule(s) with verify blocks`);
+    console.log(`Checked ${results.stats.filesChecked} file(s)\n`);
+
+    if (results.violations.length === 0) {
+      console.log(`${GREEN}✓ No violations found${RESET}\n`);
+      process.exit(0);
+    }
+
+    // Group violations by file
+    const byFile = {};
+    for (const v of results.violations) {
+      if (!byFile[v.file]) byFile[v.file] = [];
+      byFile[v.file].push(v);
+    }
+
+    for (const [file, violations] of Object.entries(byFile)) {
+      console.log(`${file}`);
+      for (const v of violations) {
+        const lineInfo = v.line ? ` ${DIM}(line ${v.line})${RESET}` : '';
+        console.log(`  ${RED}✗${RESET} ${v.message}${lineInfo}`);
+        if (v.match) {
+          console.log(`    ${DIM}→ ${v.match}${RESET}`);
         }
       }
-      const errors = result.issues.filter(i => i.severity === 'error').length;
-      const warnings = result.issues.filter(i => i.severity === 'warning').length;
-      totalErrors += errors;
-      totalWarnings += warnings;
-      if (errors === 0 && warnings === 0) totalPassed++;
+      console.log();
     }
-    console.log();
-  }
 
-  console.log('─'.repeat(50));
-  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 (totalPassed > 0) parts.push(`${GREEN}${totalPassed} passed${RESET}`);
-  console.log(parts.join(', ') + '\n');
+    console.log('─'.repeat(50));
+    console.log(`${RED}${results.stats.totalViolations} violation(s)${RESET} in ${results.stats.filesWithViolations} file(s)\n`);
+    process.exit(1);
+
+  } else {
+    // Original lint mode
+    const dir = args[0] ? path.resolve(args[0]) : cwd;
+
+    console.log(`\n🔍 cursor-lint v${VERSION}\n`);
+    console.log(`Scanning ${dir}...\n`);
+
+    const results = await lintProject(dir);
+
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    let totalPassed = 0;
+
+    for (const result of results) {
+      const relPath = path.relative(dir, result.file) || result.file;
+      console.log(relPath);
+
+      if (result.issues.length === 0) {
+        console.log(`  ${GREEN}✓ All checks passed${RESET}`);
+        totalPassed++;
+      } else {
+        for (const issue of result.issues) {
+          const icon = issue.severity === 'error' ? `${RED}✗${RESET}` : `${YELLOW}⚠${RESET}`;
+          const lineInfo = issue.line ? ` ${DIM}(line ${issue.line})${RESET}` : '';
+          console.log(`  ${icon} ${issue.message}${lineInfo}`);
+          if (issue.hint) {
+            console.log(`    ${DIM}→ ${issue.hint}${RESET}`);
+          }
+        }
+        const errors = result.issues.filter(i => i.severity === 'error').length;
+        const warnings = result.issues.filter(i => i.severity === 'warning').length;
+        totalErrors += errors;
+        totalWarnings += warnings;
+        if (errors === 0 && warnings === 0) totalPassed++;
+      }
+      console.log();
+    }
+
+    console.log('─'.repeat(50));
+    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 (totalPassed > 0) parts.push(`${GREEN}${totalPassed} passed${RESET}`);
+    console.log(parts.join(', ') + '\n');
 
-  process.exit(totalErrors > 0 ? 1 : 0);
+    process.exit(totalErrors > 0 ? 1 : 0);
+  }
 }
 
 main().catch(err => {

package/src/index.js

@@ -28,9 +28,6 @@ const VAGUE_PATTERNS = [
   'be concise',
 ];
 
-const MAX_LINES_WARNING = 150;
-const MAX_LINES_ERROR = 300;
-
 function parseFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return { found: false, data: null, error: null };
@@ -65,7 +62,6 @@ function parseFrontmatter(content) {
 async function lintMdcFile(filePath) {
   const content = fs.readFileSync(filePath, 'utf-8');
   const issues = [];
-  const lines = content.split('\n');
 
   const fm = parseFrontmatter(content);
 
@@ -95,13 +91,6 @@ async function lintMdcFile(filePath) {
     }
   }
 
-  // File length
-  if (lines.length > MAX_LINES_ERROR) {
-    issues.push({ severity: 'error', message: `File is ${lines.length} lines long — may exceed context window`, hint: 'Split into multiple .mdc files' });
-  } else if (lines.length > MAX_LINES_WARNING) {
-    issues.push({ severity: 'warning', message: `File is ${lines.length} lines long — consider splitting`, hint: 'Shorter files are more reliably loaded into context' });
-  }
-
   return { file: filePath, issues };
 }
 
@@ -125,13 +114,6 @@ async function lintCursorrules(filePath) {
     }
   }
 
-  const lines = content.split('\n');
-  if (lines.length > MAX_LINES_ERROR) {
-    issues.push({ severity: 'error', message: `File is ${lines.length} lines long — may exceed context window` });
-  } else if (lines.length > MAX_LINES_WARNING) {
-    issues.push({ severity: 'warning', message: `File is ${lines.length} lines long — consider splitting` });
-  }
-
   return { file: filePath, issues };
 }
 

package/src/verify.js

@@ -0,0 +1,304 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Verify codebase files against rules with verify: blocks
+ * Zero dependencies — uses simple YAML parsing and manual glob
+ */
+async function verifyProject(projectPath) {
+  const results = {
+    rules: [],
+    violations: [],
+    stats: {
+      rulesWithVerify: 0,
+      filesChecked: 0,
+      filesWithViolations: 0,
+      totalViolations: 0
+    }
+  };
+
+  const mdcDir = path.join(projectPath, '.cursor', 'rules');
+  if (!fs.existsSync(mdcDir)) {
+    return results;
+  }
+
+  const mdcFiles = fs.readdirSync(mdcDir).filter(f => f.endsWith('.mdc'));
+
+  for (const file of mdcFiles) {
+    const fullPath = path.join(mdcDir, file);
+    const content = fs.readFileSync(fullPath, 'utf-8');
+    const frontmatter = parseFrontmatter(content);
+    
+    if (!frontmatter.data || !frontmatter.data.verify) {
+      continue;
+    }
+
+    results.rules.push({
+      file,
+      globs: frontmatter.data.globs || ['**/*'],
+      verify: frontmatter.data.verify
+    });
+    results.stats.rulesWithVerify++;
+  }
+
+  if (results.rules.length === 0) {
+    return results;
+  }
+
+  for (const rule of results.rules) {
+    const globs = Array.isArray(rule.globs) ? rule.globs : [rule.globs];
+    const matchingFiles = findFiles(projectPath, globs);
+
+    for (const file of matchingFiles) {
+      results.stats.filesChecked++;
+      const fullPath = path.join(projectPath, file);
+      
+      try {
+        const stats = fs.statSync(fullPath);
+        if (stats.size > 1024 * 1024) continue;
+      } catch (e) {
+        continue;
+      }
+
+      let content;
+      try {
+        content = fs.readFileSync(fullPath, 'utf-8');
+      } catch (e) {
+        continue;
+      }
+
+      const fileViolations = checkFile(file, content, rule.verify, rule.file);
+      
+      if (fileViolations.length > 0) {
+        results.stats.filesWithViolations++;
+        results.stats.totalViolations += fileViolations.length;
+        results.violations.push(...fileViolations);
+      }
+    }
+  }
+
+  return results;
+}
+
+function checkFile(filePath, content, verifyBlocks, ruleFile) {
+  const violations = [];
+
+  for (const block of verifyBlocks) {
+    if (block.pattern) {
+      try {
+        const regex = new RegExp(block.pattern, 'm');
+        if (!regex.test(content)) {
+          violations.push({
+            file: filePath,
+            ruleFile,
+            type: 'missing-pattern',
+            message: block.message || `Missing required pattern: ${block.pattern}`,
+            pattern: block.pattern
+          });
+        }
+      } catch (e) {}
+    }
+
+    if (block.antipattern) {
+      try {
+        const regex = new RegExp(block.antipattern, 'gm');
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+          const lineNum = content.substring(0, match.index).split('\n').length;
+          violations.push({
+            file: filePath,
+            ruleFile,
+            type: 'antipattern',
+            message: block.message || `Forbidden pattern found: ${block.antipattern}`,
+            pattern: block.antipattern,
+            line: lineNum,
+            match: match[0].substring(0, 50) + (match[0].length > 50 ? '...' : '')
+          });
+        }
+      } catch (e) {}
+    }
+
+    if (block.required) {
+      if (!content.includes(block.required)) {
+        violations.push({
+          file: filePath,
+          ruleFile,
+          type: 'missing-required',
+          message: block.message || `Missing required string: "${block.required}"`,
+          required: block.required
+        });
+      }
+    }
+
+    if (block.forbidden) {
+      const index = content.indexOf(block.forbidden);
+      if (index !== -1) {
+        const lineNum = content.substring(0, index).split('\n').length;
+        violations.push({
+          file: filePath,
+          ruleFile,
+          type: 'forbidden',
+          message: block.message || `Forbidden string found: "${block.forbidden}"`,
+          forbidden: block.forbidden,
+          line: lineNum
+        });
+      }
+    }
+  }
+
+  return violations;
+}
+
+/**
+ * Simple frontmatter parser that handles verify blocks
+ */
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) {
+    return { data: null };
+  }
+  
+  try {
+    const data = parseSimpleYaml(match[1]);
+    return { data };
+  } catch (err) {
+    return { error: err.message };
+  }
+}
+
+/**
+ * Minimal YAML parser for frontmatter with verify blocks
+ */
+function parseSimpleYaml(text) {
+  const data = {};
+  const lines = text.split('\n');
+  let currentKey = null;
+  let currentList = null;
+  let currentItem = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    
+    // Top-level key: value
+    const kvMatch = line.match(/^(\w+):\s*(.+)$/);
+    if (kvMatch) {
+      currentKey = kvMatch[1];
+      currentList = null;
+      currentItem = null;
+      let val = kvMatch[2].trim();
+      // Handle arrays like ["*.ts", "*.tsx"]
+      if (val.startsWith('[') && val.endsWith(']')) {
+        data[currentKey] = val.slice(1, -1).split(',').map(s => s.trim().replace(/^["']|["']$/g, ''));
+      } else if (val === 'true') {
+        data[currentKey] = true;
+      } else if (val === 'false') {
+        data[currentKey] = false;
+      } else {
+        data[currentKey] = unquote(val);
+      }
+      continue;
+    }
+
+    // Top-level key with no value (starts a block)
+    const blockMatch = line.match(/^(\w+):$/);
+    if (blockMatch) {
+      currentKey = blockMatch[1];
+      currentList = [];
+      currentItem = null;
+      data[currentKey] = currentList;
+      continue;
+    }
+
+    // List item start
+    if (currentList !== null && line.match(/^\s+-\s+\w+:/)) {
+      const itemMatch = line.match(/^\s+-\s+(\w+):\s*(.+)$/);
+      if (itemMatch) {
+        currentItem = {};
+        let val = unquote(itemMatch[2].trim());
+        currentItem[itemMatch[1]] = val;
+        currentList.push(currentItem);
+      }
+      continue;
+    }
+
+    // Continuation of list item
+    if (currentItem && line.match(/^\s+\w+:/)) {
+      const contMatch = line.match(/^\s+(\w+):\s*(.+)$/);
+      if (contMatch) {
+        let val = unquote(contMatch[2].trim());
+        currentItem[contMatch[1]] = val;
+      }
+      continue;
+    }
+  }
+
+  return data;
+}
+
+/**
+ * Remove quotes and handle escape sequences
+ */
+function unquote(val) {
+  if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+    val = val.slice(1, -1);
+    // Handle YAML escape sequences in double-quoted strings
+    val = val.replace(/\\\\/g, '\\');
+  }
+  return val;
+}
+
+/**
+ * Simple file finder matching glob patterns
+ */
+function findFiles(baseDir, patterns) {
+  const files = [];
+  const ignore = ['node_modules', '.git', '.cursor'];
+  
+  function walk(dir, rel) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (e) {
+      return;
+    }
+    
+    for (const entry of entries) {
+      if (ignore.includes(entry.name)) continue;
+      
+      const fullPath = path.join(dir, entry.name);
+      const relPath = rel ? path.join(rel, entry.name) : entry.name;
+      
+      if (entry.isDirectory()) {
+        walk(fullPath, relPath);
+      } else if (entry.isFile()) {
+        for (const pattern of patterns) {
+          if (matchGlob(relPath, pattern)) {
+            files.push(relPath);
+            break;
+          }
+        }
+      }
+    }
+  }
+  
+  walk(baseDir, '');
+  return files;
+}
+
+/**
+ * Simple glob matching (supports *, **, and extensions like *.ts)
+ */
+function matchGlob(filePath, pattern) {
+  // Simple extension match: *.ts, *.tsx, etc.
+  if (pattern.startsWith('*.')) {
+    return filePath.endsWith(pattern.slice(1));
+  }
+  // **/*.ext
+  if (pattern.startsWith('**/')) {
+    return matchGlob(filePath, pattern.slice(3));
+  }
+  // Direct match
+  return filePath === pattern;
+}
+
+module.exports = { verifyProject, checkFile };