cursor-lint 0.1.1 → 0.3.0

package/package.json

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

package/src/cli.js

@@ -2,84 +2,212 @@
 
 const path = require('path');
 const { lintProject } = require('./index');
+const { verifyProject } = require('./verify');
+const { initProject } = require('./init');
 
-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.)
-`);
-  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.3.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
+  --init         Generate starter .mdc rules (auto-detects your stack)
+
+${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
+  npx cursor-lint --init       # Generate starter rules for your project
+
+${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');
+  const isInit = args.includes('--init');
+
+  if (isInit) {
+    console.log(`\n🔍 cursor-lint v${VERSION} --init\n`);
+    console.log(`Detecting stack in ${cwd}...\n`);
+
+    const results = await initProject(cwd);
+
+    const stacks = Object.entries(results.detected)
+      .filter(([_, v]) => v)
+      .map(([k]) => k.charAt(0).toUpperCase() + k.slice(1));
+
+    if (stacks.length > 0) {
+      console.log(`Detected: ${stacks.join(', ')}\n`);
+    }
+
+    if (results.created.length > 0) {
+      console.log(`${GREEN}Created:${RESET}`);
+      for (const f of results.created) {
+        console.log(`  ${GREEN}✓${RESET} .cursor/rules/${f}`);
+      }
+    }
+
+    if (results.skipped.length > 0) {
+      console.log(`\n${YELLOW}Skipped (already exist):${RESET}`);
+      for (const f of results.skipped) {
+        console.log(`  ${YELLOW}⚠${RESET} .cursor/rules/${f}`);
+      }
+    }
+
+    if (results.created.length > 0) {
+      console.log(`\n${DIM}Run cursor-lint to check these rules${RESET}`);
+      console.log(`${DIM}Run cursor-lint --verify to check code against them${RESET}\n`);
+    }
+
+    process.exit(0);
+
+  } else 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();
+    }
 
-  process.exit(totalErrors > 0 ? 1 : 0);
+    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);
+  }
 }
 
 main().catch(err => {

package/src/init.js

@@ -0,0 +1,227 @@
+const fs = require('fs');
+const path = require('path');
+
+async function initProject(projectPath) {
+  const detected = detectStack(projectPath);
+  const created = [];
+  const skipped = [];
+
+  const rulesDir = path.join(projectPath, '.cursor', 'rules');
+  
+  if (!fs.existsSync(rulesDir)) {
+    fs.mkdirSync(rulesDir, { recursive: true });
+  }
+
+  const generalResult = writeRule(rulesDir, 'general.mdc', generateGeneral());
+  if (generalResult.created) created.push(generalResult.file);
+  else skipped.push(generalResult.file);
+
+  if (detected.typescript) {
+    const result = writeRule(rulesDir, 'typescript.mdc', generateTypeScript());
+    if (result.created) created.push(result.file);
+    else skipped.push(result.file);
+  }
+
+  if (detected.react && !detected.nextjs) {
+    const result = writeRule(rulesDir, 'react.mdc', generateReact());
+    if (result.created) created.push(result.file);
+    else skipped.push(result.file);
+  }
+
+  if (detected.nextjs) {
+    const result = writeRule(rulesDir, 'nextjs.mdc', generateNextJs());
+    if (result.created) created.push(result.file);
+    else skipped.push(result.file);
+  }
+
+  if (detected.express) {
+    const result = writeRule(rulesDir, 'express.mdc', generateExpress());
+    if (result.created) created.push(result.file);
+    else skipped.push(result.file);
+  }
+
+  if (detected.python) {
+    const result = writeRule(rulesDir, 'python.mdc', generatePython());
+    if (result.created) created.push(result.file);
+    else skipped.push(result.file);
+  }
+
+  return { created, skipped, detected };
+}
+
+function detectStack(projectPath) {
+  const detected = {
+    typescript: false,
+    react: false,
+    nextjs: false,
+    express: false,
+    python: false,
+    node: false
+  };
+
+  if (fs.existsSync(path.join(projectPath, 'tsconfig.json'))) {
+    detected.typescript = true;
+  }
+
+  const pkgPath = path.join(projectPath, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    detected.node = true;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      if (allDeps.react || allDeps['react-dom']) detected.react = true;
+      if (allDeps.next) { detected.nextjs = true; detected.react = true; }
+      if (allDeps.express) detected.express = true;
+      if (allDeps.typescript || allDeps['@types/node']) detected.typescript = true;
+    } catch (e) {}
+  }
+
+  try {
+    const files = fs.readdirSync(projectPath);
+    if (files.some(f => f.endsWith('.py')) || 
+        fs.existsSync(path.join(projectPath, 'requirements.txt')) ||
+        fs.existsSync(path.join(projectPath, 'pyproject.toml'))) {
+      detected.python = true;
+    }
+  } catch (e) {}
+
+  return detected;
+}
+
+function writeRule(rulesDir, filename, content) {
+  const filePath = path.join(rulesDir, filename);
+  if (fs.existsSync(filePath)) return { file: filename, created: false };
+  fs.writeFileSync(filePath, content);
+  return { file: filename, created: true };
+}
+
+function generateGeneral() {
+  return `---
+description: General code quality rules
+alwaysApply: true
+globs: ["*"]
+verify:
+  - antipattern: "TODO"
+    message: "Resolve TODO comments before committing"
+  - antipattern: "FIXME"
+    message: "Resolve FIXME comments before committing"
+  - antipattern: "console\\\\.log"
+    message: "Remove console.log statements"
+---
+
+# General Guidelines
+
+- Write clear, self-documenting code
+- Use meaningful variable and function names
+- Keep functions small and focused
+- Remove all TODOs and FIXMEs before committing
+- No console.log in production code
+`;
+}
+
+function generateTypeScript() {
+  return `---
+description: TypeScript best practices
+alwaysApply: true
+globs: ["*.ts", "*.tsx"]
+verify:
+  - antipattern: ": any"
+    message: "Avoid using 'any' type - use proper typing"
+  - antipattern: "@ts-ignore"
+    message: "Remove @ts-ignore - fix the type error instead"
+---
+
+# TypeScript Rules
+
+- Use strict TypeScript configuration
+- Avoid \`any\` type - use \`unknown\` if type is truly unknown
+- Use type inference where possible, explicit types where helpful
+- Prefer interfaces for object shapes, types for unions/intersections
+`;
+}
+
+function generateReact() {
+  return `---
+description: React best practices
+alwaysApply: true
+globs: ["*.tsx", "*.jsx"]
+verify:
+  - antipattern: "dangerouslySetInnerHTML"
+    message: "Avoid dangerouslySetInnerHTML - use proper sanitization if needed"
+---
+
+# React Rules
+
+- Use functional components with hooks
+- Before writing a useEffect, ask: can this be computed during render?
+- Keep components small and focused
+- Use proper key props in lists (never use array index as key for dynamic lists)
+`;
+}
+
+function generateNextJs() {
+  return `---
+description: Next.js App Router best practices
+alwaysApply: true
+globs: ["*.ts", "*.tsx"]
+verify:
+  - antipattern: "getServerSideProps"
+    message: "Use App Router patterns instead of getServerSideProps"
+  - antipattern: "getStaticProps"
+    message: "Use App Router patterns instead of getStaticProps"
+---
+
+# Next.js Rules
+
+- Use App Router (app directory), not Pages Router
+- Mark components as 'use client' only when they need client-side interactivity
+- Default to Server Components
+- Use Server Actions for mutations instead of API routes
+- Use the @/ path alias for imports
+`;
+}
+
+function generateExpress() {
+  return `---
+description: Express/Node.js best practices
+alwaysApply: true
+globs: ["*.js", "*.ts"]
+verify:
+  - antipattern: "app\\\\.use\\\\(express\\\\.json\\\\(\\\\)\\\\)"
+    message: "Consider adding body size limits to express.json()"
+---
+
+# Express Rules
+
+- Use async/await with proper error handling
+- Always validate and sanitize user input
+- Use middleware for cross-cutting concerns
+- Add rate limiting for public endpoints
+`;
+}
+
+function generatePython() {
+  return `---
+description: Python best practices
+alwaysApply: true
+globs: ["*.py"]
+verify:
+  - antipattern: "print\\\\("
+    message: "Use logging instead of print statements"
+  - antipattern: "import \\\\*"
+    message: "Avoid wildcard imports - import specific names"
+  - antipattern: "except:"
+    message: "Avoid bare except - catch specific exceptions"
+---
+
+# Python Rules
+
+- Follow PEP 8 style guidelines
+- Use type hints for function signatures
+- Use logging instead of print statements
+- Handle exceptions specifically, never use bare except
+`;
+}
+
+module.exports = { initProject, detectStack };

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