cursor-doctor 1.0.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-doctor",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Fix your Cursor AI setup in seconds — health checks, diagnostics, and auto-repair for your .cursor config",
   "main": "src/index.js",
   "bin": {

package/src/audit.js

@@ -62,12 +62,12 @@ function findConflicts(rules) {
       
       if (!overlapping && !a.alwaysApply && !b.alwaysApply) continue;
       
-      // Check for contradictory instructions
-      const aBody = a.body.toLowerCase();
-      const bBody = b.body.toLowerCase();
+      // Extract directives from both rules
+      const aDirectives = extractDirectives(a.body);
+      const bDirectives = extractDirectives(b.body);
       
-      // Simple contradiction detection
-      const contradictions = findContradictions(aBody, bBody);
+      // Find conflicting directives
+      const contradictions = findDirectiveConflicts(aDirectives, bDirectives);
       if (contradictions.length > 0) {
         conflicts.push({
           fileA: a.file,
@@ -92,27 +92,126 @@ function globsOverlap(a, b) {
   return false;
 }
 
-function findContradictions(a, b) {
-  const contradictions = [];
-  const pairs = [
-    [/always use semicolons/i, /never use semicolons|no semicolons/i],
-    [/use single quotes/i, /use double quotes/i],
-    [/use tabs/i, /use spaces/i],
-    [/use css modules/i, /use tailwind|use styled-components/i],
-    [/use relative imports/i, /use absolute imports|use path aliases/i],
-    [/prefer classes/i, /prefer functions|prefer functional/i],
-    [/use default exports/i, /use named exports|no default exports/i],
-    [/use arrow functions/i, /use function declarations|avoid arrow functions/i],
-    [/use any/i, /never use any|avoid any|no any/i],
-  ];
-  
-  for (const [patA, patB] of pairs) {
-    if ((patA.test(a) && patB.test(b)) || (patB.test(a) && patA.test(b))) {
-      contradictions.push(`Conflicting style: "${patA.source}" vs "${patB.source}"`);
+function extractDirectives(text) {
+  const directives = [];
+  const lines = text.split('\n');
+  
+  // Handle compound directives like "always use X" or "never use X"
+  const compoundPattern = /\b(always|never)\s+(use|avoid|prefer|include|exclude)\s+([^.\n]{3,50})/gi;
+  // Single directives like "use X" or "avoid X"
+  const singlePattern = /\b(use|prefer|avoid|don't|do not|no|remove|add|include|exclude|enable|disable)\s+([^.\n]{3,50})/gi;
+  
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('#') || trimmed.startsWith('<!--') || trimmed.length < 5) continue;
+    
+    // Try compound pattern first
+    compoundPattern.lastIndex = 0;
+    let match = compoundPattern.exec(trimmed);
+    if (match) {
+      const modifier = match[1].toLowerCase(); // always/never
+      const action = match[2].toLowerCase();   // use/avoid/etc
+      const subject = normalizeSubject(match[3]);
+      if (subject) {
+        // Combine modifier and action: "always use" becomes "use", "never use" becomes "never"
+        const finalAction = modifier === 'never' ? 'never' : action;
+        directives.push({ action: finalAction, subject, line: trimmed });
+      }
+      continue;
+    }
+    
+    // Try single pattern
+    singlePattern.lastIndex = 0;
+    match = singlePattern.exec(trimmed);
+    if (match) {
+      const action = match[1].toLowerCase();
+      const subject = normalizeSubject(match[2]);
+      if (subject) {
+        directives.push({ action, subject, line: trimmed });
+      }
     }
   }
   
-  return contradictions;
+  return directives;
+}
+
+function normalizeSubject(text) {
+  // Lowercase and trim
+  let normalized = text.toLowerCase().trim();
+  
+  // Remove trailing punctuation
+  normalized = normalized.replace(/[.,;:!?]+$/, '');
+  
+  // Remove leading articles
+  normalized = normalized.replace(/^(the|a|an)\s+/i, '');
+  
+  // Remove extra whitespace
+  normalized = normalized.replace(/\s+/g, ' ');
+  
+  // Return null if too short or too long
+  if (normalized.length < 3 || normalized.length > 50) return null;
+  
+  return normalized;
+}
+
+function findDirectiveConflicts(aDirectives, bDirectives) {
+  const conflicts = [];
+  const opposites = {
+    'use': ['never', 'avoid', 'don\'t', 'do not', 'no', 'remove', 'exclude', 'disable'],
+    'prefer': ['avoid', 'never', 'don\'t', 'do not', 'no'],
+    'always': ['never', 'avoid', 'don\'t', 'do not', 'no'],
+    'add': ['remove', 'exclude', 'no'],
+    'include': ['exclude', 'remove', 'no'],
+    'enable': ['disable', 'no'],
+  };
+  
+  for (const aDir of aDirectives) {
+    for (const bDir of bDirectives) {
+      // Check if subjects are similar (allowing for minor variations)
+      if (subjectsSimilar(aDir.subject, bDir.subject)) {
+        // Check if actions are contradictory
+        const aAction = aDir.action;
+        const bAction = bDir.action;
+        
+        if (opposites[aAction] && opposites[aAction].includes(bAction)) {
+          conflicts.push(`"${aAction} ${aDir.subject}" vs "${bAction} ${bDir.subject}"`);
+        } else if (opposites[bAction] && opposites[bAction].includes(aAction)) {
+          conflicts.push(`"${aAction} ${aDir.subject}" vs "${bAction} ${bDir.subject}"`);
+        }
+      }
+    }
+  }
+  
+  return conflicts;
+}
+
+function subjectsSimilar(a, b) {
+  // Exact match
+  if (a === b) return true;
+  
+  // One contains the other (allowing for variations)
+  if (a.length > 5 && b.includes(a)) return true;
+  if (b.length > 5 && a.includes(b)) return true;
+  
+  // Extract key words (longer than 4 chars) and check for overlap
+  const wordsA = a.split(/\s+/).filter(w => w.length > 4);
+  const wordsB = b.split(/\s+/).filter(w => w.length > 4);
+  
+  // If they share a significant word, consider them similar
+  for (const wordA of wordsA) {
+    for (const wordB of wordsB) {
+      if (wordA === wordB || wordA.includes(wordB) || wordB.includes(wordA)) {
+        return true;
+      }
+    }
+  }
+  
+  // Remove common variations and compare
+  const cleanA = a.replace(/\b(ing|ed|s)\b/g, '').replace(/\s+/g, '');
+  const cleanB = b.replace(/\b(ing|ed|s)\b/g, '').replace(/\s+/g, '');
+  if (cleanA === cleanB) return true;
+  
+  return false;
 }
 
 function findRedundancy(rules) {

package/src/autofix.js

@@ -1,7 +1,9 @@
 const fs = require('fs');
 const path = require('path');
 const { lintProject, parseFrontmatter } = require('./index');
-const { loadRules, findRedundancy } = require('./audit');
+const { loadRules, findRedundancy, findConflicts } = require('./audit');
+const { getTemplate } = require('./templates');
+const { showStats } = require('./stats');
 
 function fixFrontmatter(content) {
   const fm = parseFrontmatter(content);
@@ -86,7 +88,7 @@ function splitOversizedFile(filePath, maxTokens = 1500) {
 }
 
 async function autoFix(dir, options = {}) {
-  const results = { fixed: [], splits: [], deduped: [], errors: [] };
+  const results = { fixed: [], splits: [], deduped: [], merged: [], annotated: [], generated: [], errors: [] };
   const rulesDir = path.join(dir, '.cursor', 'rules');
   
   if (!fs.existsSync(rulesDir)) {
@@ -153,19 +155,179 @@ async function autoFix(dir, options = {}) {
     }
   }
   
-  // 3. Remove redundancy (just flag, don't auto-delete)
+  // 3. Auto-merge redundant rules (>60% overlap)
   const rules = loadRules(dir);
   const redundant = findRedundancy(rules);
+  const merged = new Set(); // Track files we've already merged to avoid double-processing
+  
   for (const r of redundant) {
-    results.deduped.push({
-      fileA: r.fileA,
-      fileB: r.fileB,
-      overlapPct: r.overlapPct,
-      action: 'manual review needed — run `cursor-doctor audit` for details',
-    });
+    if (merged.has(r.fileA) || merged.has(r.fileB)) continue;
+    
+    if (r.overlapPct >= 60) {
+      const ruleA = rules.find(rule => rule.file === r.fileA);
+      const ruleB = rules.find(rule => rule.file === r.fileB);
+      
+      if (!ruleA || !ruleB) continue;
+      
+      // Determine which rule has broader scope
+      const aBroader = isBroaderScope(ruleA, ruleB);
+      const keepRule = aBroader ? ruleA : ruleB;
+      const mergeRule = aBroader ? ruleB : ruleA;
+      
+      // Merge bodies: combine unique lines
+      const mergedBody = mergeRuleBodies(keepRule.body, mergeRule.body);
+      
+      // Rebuild the kept file with merged content
+      const newContent = rebuildRuleFile(keepRule.fm, mergedBody);
+      
+      if (!options.dryRun) {
+        const keepPath = path.join(rulesDir, keepRule.file);
+        const mergePath = path.join(rulesDir, mergeRule.file);
+        fs.writeFileSync(keepPath, newContent, 'utf-8');
+        fs.unlinkSync(mergePath);
+      }
+      
+      results.merged.push({
+        kept: keepRule.file,
+        removed: mergeRule.file,
+        overlapPct: r.overlapPct,
+      });
+      
+      merged.add(keepRule.file);
+      merged.add(mergeRule.file);
+    } else {
+      // Just flag for manual review
+      results.deduped.push({
+        fileA: r.fileA,
+        fileB: r.fileB,
+        overlapPct: r.overlapPct,
+        action: 'manual review needed',
+      });
+    }
+  }
+  
+  // 4. Annotate conflicting rules
+  const conflicts = findConflicts(rules);
+  const annotated = new Set();
+  
+  for (const conflict of conflicts) {
+    const fileAPath = path.join(rulesDir, conflict.fileA);
+    const fileBPath = path.join(rulesDir, conflict.fileB);
+    
+    if (!annotated.has(conflict.fileA)) {
+      const content = fs.readFileSync(fileAPath, 'utf-8');
+      const annotatedContent = addConflictAnnotation(content, conflict.fileB, conflict.reason);
+      if (annotatedContent !== content) {
+        if (!options.dryRun) {
+          fs.writeFileSync(fileAPath, annotatedContent, 'utf-8');
+        }
+        results.annotated.push({ file: conflict.fileA, conflictsWith: conflict.fileB });
+        annotated.add(conflict.fileA);
+      }
+    }
+    
+    if (!annotated.has(conflict.fileB)) {
+      const content = fs.readFileSync(fileBPath, 'utf-8');
+      const annotatedContent = addConflictAnnotation(content, conflict.fileA, conflict.reason);
+      if (annotatedContent !== content) {
+        if (!options.dryRun) {
+          fs.writeFileSync(fileBPath, annotatedContent, 'utf-8');
+        }
+        results.annotated.push({ file: conflict.fileB, conflictsWith: conflict.fileA });
+        annotated.add(conflict.fileB);
+      }
+    }
+  }
+  
+  // 5. Generate missing rules for coverage gaps
+  const stats = showStats(dir);
+  const gaps = stats.coverageGaps || [];
+  
+  for (const gap of gaps) {
+    for (const suggestedRule of gap.suggestedRules) {
+      const template = getTemplate(suggestedRule);
+      if (template) {
+        const templatePath = path.join(rulesDir, template.name);
+        // Only generate if it doesn't already exist
+        if (!fs.existsSync(templatePath)) {
+          if (!options.dryRun) {
+            fs.writeFileSync(templatePath, template.content, 'utf-8');
+          }
+          results.generated.push({ file: template.name, reason: `coverage gap for ${gap.ext}` });
+        }
+      }
+    }
   }
   
   return results;
 }
 
+function isBroaderScope(ruleA, ruleB) {
+  // alwaysApply is broader than glob-targeted
+  if (ruleA.alwaysApply && !ruleB.alwaysApply) return true;
+  if (ruleB.alwaysApply && !ruleA.alwaysApply) return false;
+  
+  // More globs = broader scope
+  const aGlobCount = (ruleA.globs || []).length;
+  const bGlobCount = (ruleB.globs || []).length;
+  if (aGlobCount > bGlobCount) return true;
+  if (bGlobCount > aGlobCount) return false;
+  
+  // Default to first rule
+  return true;
+}
+
+function mergeRuleBodies(bodyA, bodyB) {
+  const linesA = bodyA.split('\n');
+  const linesB = bodyB.split('\n');
+  
+  const merged = [...linesA];
+  const seenLines = new Set(linesA.map(l => l.trim()));
+  
+  for (const line of linesB) {
+    const trimmed = line.trim();
+    if (trimmed.length > 0 && !seenLines.has(trimmed)) {
+      merged.push(line);
+      seenLines.add(trimmed);
+    }
+  }
+  
+  return merged.join('\n');
+}
+
+function rebuildRuleFile(frontmatter, body) {
+  if (!frontmatter.found || !frontmatter.data) {
+    return body;
+  }
+  
+  const fmLines = [];
+  for (const [k, v] of Object.entries(frontmatter.data)) {
+    if (typeof v === 'boolean') fmLines.push(`${k}: ${v}`);
+    else if (typeof v === 'string' && (v.startsWith('[') || v === 'true' || v === 'false')) fmLines.push(`${k}: ${v}`);
+    else fmLines.push(`${k}: ${v}`);
+  }
+  
+  return `---\n${fmLines.join('\n')}\n---\n${body}`;
+}
+
+function addConflictAnnotation(content, conflictFile, reason) {
+  const annotation = `<!-- cursor-doctor: conflicts with ${conflictFile} — review manually -->\n`;
+  
+  // Check if already annotated
+  if (content.includes('cursor-doctor: conflicts with')) {
+    return content;
+  }
+  
+  // Add after frontmatter if present
+  const fmMatch = content.match(/^---\n[\s\S]*?\n---\n/);
+  if (fmMatch) {
+    const fm = fmMatch[0];
+    const rest = content.slice(fm.length);
+    return fm + annotation + rest;
+  }
+  
+  // Otherwise add at top
+  return annotation + content;
+}
+
 module.exports = { autoFix, fixFrontmatter, splitOversizedFile };

package/src/cli.js

@@ -11,7 +11,7 @@ const { autoFix } = require('./autofix');
 const { isLicensed, activateLicense } = require('./license');
 const { fixProject } = require('./fix');
 
-const VERSION = '1.0.0';
+const VERSION = '1.1.0';
 
 const RED = '\x1b[31m';
 const YELLOW = '\x1b[33m';
@@ -291,7 +291,10 @@ async function main() {
       process.exit(1);
     }
 
-    if (results.fixed.length === 0 && results.splits.length === 0 && results.deduped.length === 0) {
+    var totalActions = results.fixed.length + results.splits.length + results.merged.length + 
+                       results.annotated.length + results.generated.length + results.deduped.length;
+
+    if (totalActions === 0) {
       console.log('  ' + GREEN + String.fromCharCode(10003) + RESET + ' Nothing to fix. Setup looks clean.');
       console.log();
       process.exit(0);
@@ -301,10 +304,19 @@ async function main() {
       console.log('  ' + GREEN + String.fromCharCode(10003) + RESET + ' ' + results.fixed[i].file + ': ' + results.fixed[i].change);
     }
     for (var i = 0; i < results.splits.length; i++) {
-      console.log('  ' + GREEN + String.fromCharCode(10003) + RESET + ' Split ' + results.splits[i].file + ' -> ' + results.splits[i].parts.join(', '));
+      console.log('  ' + BLUE + String.fromCharCode(9986) + RESET + ' Split ' + results.splits[i].file + ' -> ' + results.splits[i].parts.join(', '));
+    }
+    for (var i = 0; i < results.merged.length; i++) {
+      console.log('  ' + CYAN + String.fromCharCode(8645) + RESET + ' Merged ' + results.merged[i].removed + ' into ' + results.merged[i].kept + ' (' + results.merged[i].overlapPct + '% overlap)');
+    }
+    for (var i = 0; i < results.annotated.length; i++) {
+      console.log('  ' + YELLOW + String.fromCharCode(9888) + RESET + ' Annotated ' + results.annotated[i].file + ' (conflicts with ' + results.annotated[i].conflictsWith + ')');
+    }
+    for (var i = 0; i < results.generated.length; i++) {
+      console.log('  ' + GREEN + String.fromCharCode(10010) + RESET + ' Generated ' + results.generated[i].file + ' (' + results.generated[i].reason + ')');
     }
     for (var i = 0; i < results.deduped.length; i++) {
-      console.log('  ' + YELLOW + '!' + RESET + ' ' + results.deduped[i].fileA + ' + ' + results.deduped[i].fileB + ': ' + results.deduped[i].overlapPct + '% overlap');
+      console.log('  ' + YELLOW + '!' + RESET + ' ' + results.deduped[i].fileA + ' + ' + results.deduped[i].fileB + ': ' + results.deduped[i].overlapPct + '% overlap (manual review)');
     }
     console.log();
     process.exit(0);

package/src/templates.js

@@ -0,0 +1,488 @@
+// Template rules for common stacks
+// Each template should be genuinely useful, not generic filler
+
+const TEMPLATES = {
+  typescript: {
+    name: 'typescript.mdc',
+    content: `---
+description: TypeScript conventions and best practices
+globs: ["*.ts", "*.tsx"]
+alwaysApply: false
+---
+
+# TypeScript Guidelines
+
+## Type Safety
+- Prefer explicit return types on exported functions
+- Use strict TypeScript config: enable noImplicitAny, strictNullChecks, noUncheckedIndexedAccess
+- Avoid \`any\` — use \`unknown\` for truly dynamic values, then narrow with type guards
+- Use discriminated unions instead of optional properties when modeling states
+
+## Naming
+- Interfaces: PascalCase (e.g., \`UserProfile\`)
+- Type aliases: PascalCase (e.g., \`RequestHandler\`)
+- Generic parameters: single letter (T, K, V) for simple cases, descriptive names for complex ones
+
+## Organization
+- Colocate types with the code that uses them
+- Export types from index files for public API
+- Use \`type\` for unions/intersections, \`interface\` for object shapes that might be extended
+
+## Patterns
+- Use \`satisfies\` to validate object literals without widening types
+- Prefer tuple types with labeled elements: \`[name: string, age: number]\`
+- Use template literal types for string patterns (e.g., route keys)
+`,
+  },
+
+  react: {
+    name: 'react.mdc',
+    content: `---
+description: React component patterns and conventions
+globs: ["*.tsx", "*.jsx"]
+alwaysApply: false
+---
+
+# React Guidelines
+
+## Component Structure
+- Prefer function components with hooks over class components
+- Use named exports for components (easier to refactor and tree-shake)
+- Extract custom hooks when logic is reused across >2 components
+- Keep components under 150 lines — split into subcomponents or hooks if longer
+
+## Hooks
+- Declare hooks at the top level, never conditionally
+- Use \`useCallback\` for functions passed to memoized children
+- Use \`useMemo\` only when profiling shows a performance benefit
+- Custom hooks should start with \`use\` prefix
+
+## Props
+- Destructure props in the function signature for clarity
+- Use TypeScript interfaces for prop types, not inline types
+- Prefer required props over optional with defaults
+
+## State Management
+- Prefer URL state (query params) for shareable UI state
+- Use context for deeply-nested data, not as global store
+- Colocate state with the component that owns it — lift only when needed
+
+## Patterns
+- Use compound components for related UI groups (e.g., Tabs)
+- Avoid prop drilling — use composition or context after 2-3 levels
+- Keep JSX readable: extract complex conditionals into variables
+`,
+  },
+
+  nextjs: {
+    name: 'nextjs.mdc',
+    content: `---
+description: Next.js app architecture and routing
+globs: ["*.ts", "*.tsx", "next.config.*"]
+alwaysApply: false
+---
+
+# Next.js Guidelines
+
+## App Router (13+)
+- Use Server Components by default — add \`'use client'\` only when needed (interactivity, hooks, browser APIs)
+- Server Components: data fetching, async/await directly in component
+- Client Components: event handlers, state, effects, browser-only code
+- Never import Server Components into Client Components
+
+## Routing
+- Colocate components in route folders, use \`_components/\` prefix for private files
+- Use Route Handlers (route.ts) for API endpoints, not pages/api
+- Dynamic routes: \`[id]\` for single, \`[...slug]\` for catch-all
+- Parallel routes and intercepting routes for modals and multi-pane UIs
+
+## Data Fetching
+- Use \`fetch\` in Server Components — automatic deduplication and caching
+- Prefer server-side fetching over client-side for initial data
+- Use \`loading.tsx\` for instant loading states (Suspense boundaries)
+- Use \`error.tsx\` for error boundaries
+
+## Performance
+- Use \`next/image\` for all images — automatic optimization
+- Enable PPR (Partial Prerendering) when available
+- Use \`revalidate\` in fetch options for ISR, not getStaticProps
+- Lazy load client components with \`next/dynamic\`
+`,
+  },
+
+  python: {
+    name: 'python.mdc',
+    content: `---
+description: Python style and conventions
+globs: ["*.py"]
+alwaysApply: false
+---
+
+# Python Guidelines
+
+## Style
+- Follow PEP 8 for formatting (use black or ruff for auto-formatting)
+- Type hints on all public functions: \`def get_user(id: int) -> User | None:\`
+- Docstrings for modules, classes, and public functions (Google or NumPy style)
+- Max line length: 88 characters (black default)
+
+## Structure
+- One class per file unless tightly coupled
+- Group imports: stdlib, third-party, local (separated by blank lines)
+- Use \`__init__.py\` to expose public API, keep internals private with \`_prefix\`
+
+## Typing
+- Use \`from __future__ import annotations\` for modern type syntax in 3.9+
+- Prefer \`list[str]\` over \`List[str]\` (3.9+)
+- Use \`| None\` instead of \`Optional\` (3.10+)
+- Use Protocol for structural subtyping, not abstract classes
+
+## Patterns
+- Use dataclasses for data containers, not dicts
+- Context managers (\`with\`) for resource management
+- Comprehensions for simple transformations, generator expressions for large data
+- Avoid mutable default arguments — use \`None\` and initialize in function body
+`,
+  },
+
+  django: {
+    name: 'django.mdc',
+    content: `---
+description: Django models, views, and architecture
+globs: ["*.py"]
+alwaysApply: false
+---
+
+# Django Guidelines
+
+## Models
+- Singular names: \`User\`, \`Order\` (Django pluralizes automatically)
+- Use \`models.TextChoices\` or \`models.IntegerChoices\` for choice fields
+- Indexes: add \`db_index=True\` to foreign keys and frequently queried fields
+- Use \`select_related\` for one-to-one/foreign key, \`prefetch_related\` for many-to-many
+- Custom managers for reusable querysets
+
+## Views
+- Prefer class-based views for CRUD, function-based for custom logic
+- Use \`get_object_or_404\` instead of manual try/except for single-object lookups
+- Keep views thin — move business logic to models, managers, or services
+- Return JSON with \`JsonResponse\`, not serialized strings
+
+## URLs
+- Use path converters: \`path('users/<int:id>/', ...)\` not regex
+- Name all URL patterns: \`name='user-detail'\`
+- Namespace apps: \`app_name = 'blog'\` in urls.py
+
+## Queries
+- Use \`.only()\` and \`.defer()\` to limit fields when fetching large models
+- Annotate/aggregate at database level, not Python loops
+- Use \`Q\` objects for complex lookups, not raw SQL
+- Avoid N+1 queries — use debug toolbar to catch them
+
+## Settings
+- Use environment variables for secrets (python-decouple or django-environ)
+- Split settings: base.py, dev.py, prod.py
+- Never commit SECRET_KEY or database credentials
+`,
+  },
+
+  go: {
+    name: 'go.mdc',
+    content: `---
+description: Go idioms and best practices
+globs: ["*.go"]
+alwaysApply: false
+---
+
+# Go Guidelines
+
+## Style
+- Run \`gofmt\` (automatic with most editors)
+- Use \`golangci-lint\` for comprehensive linting
+- Package names: lowercase, single word, no underscores
+- Exported names: PascalCase; unexported: camelCase
+
+## Error Handling
+- Always check errors immediately: \`if err != nil { return err }\`
+- Wrap errors with context: \`fmt.Errorf("failed to save user: %w", err)\`
+- Use \`errors.Is\` and \`errors.As\` for sentinel and type checking
+- Return errors, don't panic (except for truly unrecoverable situations)
+
+## Concurrency
+- Use channels for communication, mutexes for state protection
+- Close channels from sender side, never receiver
+- Use \`context.Context\` for cancellation and timeouts
+- \`defer\` unlock calls immediately after lock: \`mu.Lock(); defer mu.Unlock()\`
+
+## Organization
+- Keep packages focused: one responsibility per package
+- Use internal/ for private code (enforced by compiler)
+- Minimize dependencies between packages (dependency graph should be acyclic)
+
+## Patterns
+- Accept interfaces, return structs
+- Use \`io.Reader\`/\`io.Writer\` for streaming data
+- Constructor pattern: \`func NewClient(opts ...Option) *Client\`
+- Avoid getters/setters — expose fields directly or use methods that do work
+`,
+  },
+
+  rust: {
+    name: 'rust.mdc',
+    content: `---
+description: Rust patterns and idiomatic code
+globs: ["*.rs"]
+alwaysApply: false
+---
+
+# Rust Guidelines
+
+## Ownership
+- Prefer borrowing (\`&T\`, \`&mut T\`) over owned values when possible
+- Use \`.clone()\` explicitly — no hidden copies
+- Use \`Cow<str>\` when you might need to clone, but usually don't
+- \`Arc<T>\` for shared ownership across threads, \`Rc<T>\` for single-threaded
+
+## Error Handling
+- Use \`Result<T, E>\` for recoverable errors, panic for bugs
+- Use \`?\` operator to propagate errors, not manual \`match\`
+- Use \`thiserror\` for library errors, \`anyhow\` for application errors
+- Implement \`std::error::Error\` for custom error types
+
+## Types
+- Use newtypes for domain concepts: \`struct UserId(u64)\`
+- Prefer \`Option<T>\` over nullable pointers
+- Use \`enum\` for state machines and variants
+- Use \`#[non_exhaustive]\` on public enums for forward compatibility
+
+## Patterns
+- Builder pattern for complex construction: \`Config::builder().timeout(30).build()\`
+- Use \`impl Trait\` for return types instead of boxing when possible
+- Use \`#[derive(Debug, Clone)]\` by default, add others as needed
+- Avoid \`unwrap()\` in production code — use \`expect()\` with a message or propagate errors
+
+## Performance
+- Use iterators, not loops — they're zero-cost and composable
+- Prefer \`&[T]\` over \`&Vec<T>\` in function signatures
+- Use \`#[inline]\` sparingly, only after profiling
+- Use \`cargo flamegraph\` or \`perf\` for profiling
+`,
+  },
+
+  vue: {
+    name: 'vue.mdc',
+    content: `---
+description: Vue 3 composition API and component patterns
+globs: ["*.vue"]
+alwaysApply: false
+---
+
+# Vue 3 Guidelines
+
+## Composition API
+- Use \`<script setup>\` for all components (less boilerplate)
+- Declare reactive state with \`ref\` for primitives, \`reactive\` for objects
+- Extract reusable logic into composables (functions that start with \`use\`)
+- Use \`computed\` for derived state, not methods
+
+## Component Structure
+- Template-first: put \`<template>\` before \`<script>\`
+- Single file components: template, script, style in one .vue file
+- Keep components under 200 lines — extract child components if longer
+- Use \`defineProps\` and \`defineEmits\` (no imports needed with \`<script setup>\`)
+
+## Props and Events
+- Use TypeScript for prop types: \`defineProps<{ userId: number }>()\`
+- Emit events for child-to-parent communication, not prop mutations
+- Use \`v-model\` for two-way binding, with \`update:modelValue\` event
+
+## Directives
+- Use \`v-if\` for conditional rendering, \`v-show\` for toggling visibility (DOM stays)
+- Use \`v-for\` with \`:key\` — keys should be stable and unique
+- Use \`v-memo\` for expensive lists that rarely change
+
+## Performance
+- Use \`shallowRef\` for large objects that are replaced, not mutated
+- Use \`v-once\` for static content that never changes
+- Lazy load routes with \`() => import('./views/About.vue')\`
+`,
+  },
+
+  svelte: {
+    name: 'svelte.mdc',
+    content: `---
+description: Svelte component patterns and reactivity
+globs: ["*.svelte"]
+alwaysApply: false
+---
+
+# Svelte Guidelines
+
+## Reactivity
+- Reactive statements: \`$: doubled = count * 2\` (re-runs when dependencies change)
+- Use \`$:\` for side effects: \`$: console.log('count is', count)\`
+- Update arrays/objects with assignment, not mutation: \`items = [...items, newItem]\`
+- Use stores (\`writable\`, \`readable\`, \`derived\`) for global state
+
+## Component Structure
+- Export variables to make them props: \`export let name\`
+- Use \`$$props\` and \`$$restProps\` to forward props
+- Emit events with \`createEventDispatcher\` or bubble with \`on:click\`
+- Use slots for composition: \`<slot />\` and named slots
+
+## Directives
+- \`use:action\` for lifecycle hooks on DOM elements
+- \`bind:this\` to get DOM references
+- \`class:active={isActive}\` for conditional classes
+- \`on:event|modifiers\` for event handling (\`preventDefault\`, \`stopPropagation\`, etc.)
+
+## SvelteKit (if used)
+- Use \`+page.svelte\` for routes, \`+page.ts\` for load functions
+- Use \`+layout.svelte\` for shared layouts
+- Use \`$app/stores\` for page, navigating, updated stores
+- Form actions in \`+page.server.ts\` for progressive enhancement
+
+## Patterns
+- Keep logic in \`<script>\`, not template — complex expressions should be variables
+- Use \`{#await promise}\` for async data in templates
+- Use transitions: \`transition:fade\`, \`in:fly\`, \`out:scale\`
+`,
+  },
+
+  tailwind: {
+    name: 'tailwind.mdc',
+    content: `---
+description: Tailwind CSS utility patterns and conventions
+globs: ["*.css", "*.tsx", "*.jsx"]
+alwaysApply: false
+---
+
+# Tailwind CSS Guidelines
+
+## Utility Classes
+- Use utilities for layout, spacing, colors — avoid custom CSS when possible
+- Group utilities logically: layout → spacing → typography → colors → effects
+- Use \`@apply\` sparingly, only for truly reusable patterns (extract components instead)
+- Use arbitrary values when needed: \`w-[127px]\`, \`text-[#1da1f2]\`
+
+## Responsive Design
+- Mobile-first: default classes apply to all sizes, add \`md:\`, \`lg:\` for larger screens
+- Use container utilities: \`container mx-auto px-4\`
+- Use responsive utilities: \`grid-cols-1 md:grid-cols-2 lg:grid-cols-3\`
+
+## Dark Mode
+- Configure dark mode in tailwind.config (class or media strategy)
+- Use \`dark:\` variant: \`bg-white dark:bg-gray-800\`
+- Group related variants: \`text-gray-900 dark:text-gray-100\`
+
+## Customization
+- Extend theme in tailwind.config.js, don't replace defaults
+- Use CSS variables for dynamic values (e.g., user themes)
+- Use \`clsx\` or \`cn\` helper for conditional classes
+- Keep config organized: colors, spacing, fonts, plugins
+
+## Components
+- Extract components when same classes repeat >3 times
+- Use \`@layer components\` for component classes, \`@layer utilities\` for custom utilities
+- Prefix custom classes to avoid conflicts: \`btn-primary\` not \`primary\`
+`,
+  },
+
+  express: {
+    name: 'express.mdc',
+    content: `---
+description: Express.js API routes and middleware
+globs: ["*.js", "*.ts"]
+alwaysApply: false
+---
+
+# Express Guidelines
+
+## Routing
+- Use Router() for modular route definitions: \`const router = express.Router()\`
+- Group routes by resource: \`/api/users\`, \`/api/posts\`
+- Use route parameters for dynamic segments: \`/users/:id\`
+- Use query strings for filters: \`/users?role=admin\`
+
+## Middleware
+- Order matters: error handlers go last, after all routes
+- Use \`app.use(express.json())\` for JSON body parsing
+- Use \`next()\` to pass control, \`next(err)\` to trigger error handler
+- Keep middleware focused: one responsibility per function
+
+## Error Handling
+- Use async error wrapper to avoid try/catch in every route
+- Centralized error handler: \`app.use((err, req, res, next) => {...})\`
+- Return consistent error format: \`{ error: { message, code, details } }\`
+- Use HTTP status codes correctly: 400 (bad request), 401 (unauthorized), 404 (not found), 500 (server error)
+
+## Request/Response
+- Validate input before processing (use express-validator or zod)
+- Use \`res.status(code).json(data)\`, not \`res.send\`
+- Set appropriate headers: \`Content-Type\`, \`Cache-Control\`
+- Use \`res.locals\` to pass data between middleware
+
+## Security
+- Use helmet for security headers
+- Rate limit with express-rate-limit
+- Sanitize input to prevent XSS and SQL injection
+- Use CORS middleware, configure allowed origins
+`,
+  },
+
+  testing: {
+    name: 'testing.mdc',
+    content: `---
+description: Testing patterns and conventions
+globs: ["*.test.*", "*.spec.*"]
+alwaysApply: false
+---
+
+# Testing Guidelines
+
+## Structure
+- One test file per source file: \`user.ts\` → \`user.test.ts\`
+- Use \`describe\` blocks to group related tests
+- Test names: \`it('should <expected behavior> when <condition>')\`
+- Arrange-Act-Assert pattern: setup → execute → verify
+
+## What to Test
+- Public API, not implementation details
+- Edge cases: null, undefined, empty arrays, boundary values
+- Error paths: what happens when things fail
+- Integration points: API calls, database queries, external services
+
+## Mocking
+- Mock external dependencies (API clients, databases), not your own code
+- Use dependency injection to make code testable
+- Prefer test doubles that verify behavior (spies), not just return values (stubs)
+- Reset mocks between tests: \`beforeEach(() => jest.clearAllMocks())\`
+
+## Assertions
+- One logical assertion per test (multiple expect calls are OK if testing same outcome)
+- Use specific matchers: \`toEqual\` for deep equality, \`toBe\` for identity
+- Use \`toThrow\` for error testing, with specific error message or type
+
+## Best Practices
+- Tests should be fast (<1s per test file ideal)
+- Tests should be independent — order shouldn't matter
+- Avoid snapshot tests for complex objects (brittle)
+- Use factories or builders for test data, not inline objects
+`,
+  },
+};
+
+function getTemplate(stack) {
+  const key = stack.toLowerCase();
+  return TEMPLATES[key] || null;
+}
+
+function getAllTemplates() {
+  return Object.values(TEMPLATES);
+}
+
+function getTemplateNames() {
+  return Object.keys(TEMPLATES);
+}
+
+module.exports = { getTemplate, getAllTemplates, getTemplateNames, TEMPLATES };