cursor-doctor 1.0.0

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/license.js

@@ -0,0 +1,88 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const crypto = require('crypto');
+
+const PRODUCT_PERMALINK = 'cursor-doctor-pro';
+const LICENSE_FILE = '.cursor-doctor-license';
+const SALT = 'cursor-doctor-v1';
+
+function getLicensePath() {
+  const home = process.env.HOME || process.env.USERPROFILE || '.';
+  return path.join(home, LICENSE_FILE);
+}
+
+function isLicensed() {
+  var p = getLicensePath();
+  if (!fs.existsSync(p)) return false;
+  try {
+    var stored = fs.readFileSync(p, 'utf-8').trim();
+    return stored.length === 64 && /^[a-f0-9]+$/.test(stored);
+  } catch (e) { return false; }
+}
+
+function verifyWithGumroad(key) {
+  return new Promise(function(resolve) {
+    var postData = 'product_permalink=' + encodeURIComponent(PRODUCT_PERMALINK) + '&license_key=' + encodeURIComponent(key.trim());
+
+    var options = {
+      hostname: 'api.gumroad.com',
+      path: '/v2/licenses/verify',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Content-Length': Buffer.byteLength(postData)
+      }
+    };
+
+    var req = https.request(options, function(res) {
+      var body = '';
+      res.on('data', function(chunk) { body += chunk; });
+      res.on('end', function() {
+        try {
+          var json = JSON.parse(body);
+          if (json.success === true && json.purchase && !json.purchase.refunded && !json.purchase.chargebacked) {
+            resolve({ valid: true });
+          } else if (json.success === false) {
+            resolve({ valid: false, error: 'Invalid license key' });
+          } else {
+            resolve({ valid: false, error: 'Key is refunded or chargebacked' });
+          }
+        } catch (e) {
+          resolve({ valid: false, error: 'Could not parse Gumroad response' });
+        }
+      });
+    });
+
+    req.on('error', function(e) {
+      resolve({ valid: false, error: 'Could not reach Gumroad: ' + e.message });
+    });
+
+    req.write(postData);
+    req.end();
+  });
+}
+
+async function activateLicense(dir, key) {
+  if (!key || key.trim().length < 8) {
+    return { ok: false, error: 'Key too short' };
+  }
+
+  var result = await verifyWithGumroad(key);
+
+  if (!result.valid) {
+    return { ok: false, error: result.error };
+  }
+
+  var hash = crypto.createHash('sha256').update(SALT + ':' + key.trim()).digest('hex');
+  var homePath = getLicensePath();
+
+  try {
+    fs.writeFileSync(homePath, hash + '\n', 'utf-8');
+    return { ok: true, path: homePath };
+  } catch (e) {
+    return { ok: false, error: 'Failed to save license: ' + e.message };
+  }
+}
+
+module.exports = { isLicensed, activateLicense };

package/src/migrate.js

@@ -0,0 +1,118 @@
+const fs = require('fs');
+const path = require('path');
+
+function migrate(dir) {
+  const cursorrules = path.join(dir, '.cursorrules');
+  const result = { created: [], skipped: [], source: null, error: null };
+
+  if (!fs.existsSync(cursorrules)) {
+    result.error = 'No .cursorrules file found in this directory';
+    return result;
+  }
+
+  const content = fs.readFileSync(cursorrules, 'utf-8').trim();
+  result.source = { file: '.cursorrules', chars: content.length, lines: content.split('\n').length };
+
+  if (content.length === 0) {
+    result.error = '.cursorrules file is empty';
+    return result;
+  }
+
+  const rulesDir = path.join(dir, '.cursor', 'rules');
+  fs.mkdirSync(rulesDir, { recursive: true });
+
+  // Try to split by markdown headings (## or #)
+  const sections = splitBySections(content);
+
+  if (sections.length <= 1) {
+    // Single file migration
+    const filename = 'project-rules.mdc';
+    const destPath = path.join(rulesDir, filename);
+    if (fs.existsSync(destPath)) {
+      result.skipped.push(filename);
+    } else {
+      const mdc = wrapInMdc(content, 'Project rules migrated from .cursorrules');
+      fs.writeFileSync(destPath, mdc, 'utf-8');
+      result.created.push(filename);
+    }
+  } else {
+    // Multi-file migration
+    for (const section of sections) {
+      const filename = slugify(section.title) + '.mdc';
+      const destPath = path.join(rulesDir, filename);
+      if (fs.existsSync(destPath)) {
+        result.skipped.push(filename);
+      } else {
+        const mdc = wrapInMdc(section.body, section.title);
+        fs.writeFileSync(destPath, mdc, 'utf-8');
+        result.created.push(filename);
+      }
+    }
+  }
+
+  return result;
+}
+
+function splitBySections(content) {
+  const lines = content.split('\n');
+  const sections = [];
+  let currentTitle = null;
+  let currentBody = [];
+
+  for (const line of lines) {
+    const headingMatch = line.match(/^#{1,2}\s+(.+)/);
+    if (headingMatch) {
+      if (currentTitle !== null) {
+        sections.push({ title: currentTitle, body: currentBody.join('\n').trim() });
+      }
+      currentTitle = headingMatch[1].trim();
+      currentBody = [];
+    } else {
+      currentBody.push(line);
+    }
+  }
+
+  // Push last section
+  if (currentTitle !== null) {
+    sections.push({ title: currentTitle, body: currentBody.join('\n').trim() });
+  }
+
+  // If no headings found, check for content before first heading
+  if (sections.length === 0) {
+    return [{ title: 'Project Rules', body: content }];
+  }
+
+  // If there's content before the first heading, include it
+  const firstHeadingIdx = content.search(/^#{1,2}\s+/m);
+  if (firstHeadingIdx > 0) {
+    const preamble = content.slice(0, firstHeadingIdx).trim();
+    if (preamble.length > 20) {
+      sections.unshift({ title: 'General', body: preamble });
+    }
+  }
+
+  // Filter out empty sections
+  return sections.filter(s => s.body.length > 10);
+}
+
+function slugify(title) {
+  return title
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 40) || 'rule';
+}
+
+function wrapInMdc(body, description) {
+  return `---
+description: "${description.replace(/"/g, '\\"')}"
+alwaysApply: true
+---
+
+${body}
+`;
+}
+
+module.exports = { migrate };

package/src/order.js

@@ -0,0 +1,131 @@
+const fs = require('fs');
+const path = require('path');
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return { found: false, data: null };
+
+  const data = {};
+  const lines = match[1].split('\n');
+  for (const line of lines) {
+    const colonIdx = line.indexOf(':');
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const rawVal = line.slice(colonIdx + 1).trim();
+    if (rawVal === 'true') data[key] = true;
+    else if (rawVal === 'false') data[key] = false;
+    else if (rawVal.startsWith('"') && rawVal.endsWith('"')) data[key] = rawVal.slice(1, -1);
+    else data[key] = rawVal;
+  }
+  return { found: true, data };
+}
+
+function parseGlobs(globVal) {
+  if (!globVal) return [];
+  if (typeof globVal === 'string') {
+    const trimmed = globVal.trim();
+    if (trimmed.startsWith('[')) {
+      return trimmed.slice(1, -1).split(',').map(g => g.trim().replace(/^["']|["']$/g, '')).filter(Boolean);
+    }
+    return trimmed.split(',').map(g => g.trim().replace(/^["']|["']$/g, '')).filter(Boolean);
+  }
+  return [];
+}
+
+function estimateTokens(text) {
+  // Rough estimate: ~4 chars per token for English text
+  return Math.ceil(text.length / 4);
+}
+
+function showLoadOrder(dir) {
+  const results = {
+    hasCursorrules: false,
+    rules: [],
+    warnings: [],
+  };
+
+  // Check for .cursorrules
+  const cursorrules = path.join(dir, '.cursorrules');
+  if (fs.existsSync(cursorrules)) {
+    results.hasCursorrules = true;
+    const content = fs.readFileSync(cursorrules, 'utf-8');
+    const lines = content.split('\n').length;
+    results.rules.push({
+      file: '.cursorrules',
+      tier: 'always',
+      globs: [],
+      description: '(legacy format)',
+      alwaysApply: true,
+      lines,
+      tokens: estimateTokens(content),
+      priority: 0, // lowest priority — overridden by .mdc
+    });
+  }
+
+  // Check .cursor/rules/*.mdc
+  const rulesDir = path.join(dir, '.cursor', 'rules');
+  if (fs.existsSync(rulesDir) && fs.statSync(rulesDir).isDirectory()) {
+    const files = fs.readdirSync(rulesDir).filter(f => f.endsWith('.mdc')).sort();
+
+    for (const file of files) {
+      const filePath = path.join(rulesDir, file);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const fm = parseFrontmatter(content);
+      const lines = content.split('\n').length;
+      const tokens = estimateTokens(content);
+
+      if (!fm.found || !fm.data) {
+        results.rules.push({
+          file,
+          tier: 'manual',
+          globs: [],
+          description: '(no frontmatter)',
+          alwaysApply: false,
+          lines,
+          tokens,
+        });
+        results.warnings.push(`${file}: Missing frontmatter — rule may not load at all`);
+        continue;
+      }
+
+      const globs = parseGlobs(fm.data.globs);
+      const alwaysApply = fm.data.alwaysApply === true;
+      const description = fm.data.description || '';
+
+      let tier;
+      if (alwaysApply) {
+        tier = 'always';
+      } else if (globs.length > 0) {
+        tier = 'glob';
+      } else {
+        tier = 'manual';
+        results.warnings.push(`${file}: No alwaysApply and no globs — this rule may never activate in agent mode`);
+      }
+
+      results.rules.push({
+        file,
+        tier,
+        globs,
+        description,
+        alwaysApply,
+        lines,
+        tokens,
+      });
+    }
+  }
+
+  // Sort within tiers: always first, then glob, then manual
+  // Within each tier, sort by filename (alphabetical = filesystem order)
+  const tierOrder = { always: 0, glob: 1, manual: 2 };
+  results.rules.sort((a, b) => {
+    if (tierOrder[a.tier] !== tierOrder[b.tier]) return tierOrder[a.tier] - tierOrder[b.tier];
+    // .cursorrules always last within 'always' tier (lowest priority)
+    if (a.file === '.cursorrules') return -1;
+    if (b.file === '.cursorrules') return 1;
+    return a.file.localeCompare(b.file);
+  });
+
+  return results;
+}
+
+module.exports = { showLoadOrder };