docrev 0.6.13 → 0.7.6

package/lib/config.js

@@ -58,3 +58,22 @@ export function setUserName(name) {
 export function getConfigPath() {
   return CONFIG_PATH;
 }
+
+/**
+ * Get default sections for new projects
+ * @returns {string[]|null}
+ */
+export function getDefaultSections() {
+  const config = loadUserConfig();
+  return config.defaultSections || null;
+}
+
+/**
+ * Set default sections for new projects
+ * @param {string[]} sections - Array of section names (without .md extension)
+ */
+export function setDefaultSections(sections) {
+  const config = loadUserConfig();
+  config.defaultSections = sections;
+  saveUserConfig(config);
+}

package/lib/crossref.js

@@ -9,6 +9,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
+import YAML from 'yaml';
 
 /**
  * Patterns for detecting hardcoded references
@@ -27,6 +28,8 @@ const DETECTION_PATTERNS = {
   // Matches: "1", "1a", "1-3", "1a-c", "1, 2, 3", "1 and 2", "1, 2 and 3", "1, 2, and 3"
   // Separator: comma/dash/ampersand, optionally followed by "and"
   // Standalone letters must be followed by separator, punctuation, or word boundary
+  // Also handles: "see Figure 1", "(Fig. 1)", "in Figures 1–3"
+  // Note: 'gi' flag makes these case-insensitive, so "figure 1" is also matched
   figure: /\b(Figures?|Figs?\.?)\s+((?:\d+|S\d+)[a-z]?(?:(?:\s*[-–—,&]\s*(?:and\s+)?|\s+and\s+)(?:(?:\d+|S\d+)[a-z]?|[a-z]\b))*)/gi,
 
   table: /\b(Tables?|Tabs?\.?)\s+((?:\d+|S\d+)[a-z]?(?:(?:\s*[-–—,&]\s*(?:and\s+)?|\s+and\s+)(?:(?:\d+|S\d+)[a-z]?|[a-z]\b))*)/gi,
@@ -34,6 +37,19 @@ const DETECTION_PATTERNS = {
   equation: /\b(Equations?|Eqs?\.?)\s+((?:\d+)[a-z]?(?:(?:\s*[-–—,&]\s*(?:and\s+)?|\s+and\s+)(?:(?:\d+)[a-z]?|[a-z]\b))*)/gi,
 };
 
+/**
+ * Patterns to EXCLUDE from detection (false positives)
+ * These look like references but aren't (e.g., "Table of Contents", "Figure skating")
+ */
+const EXCLUSION_PATTERNS = [
+  /\bTable\s+of\s+Contents?\b/gi,
+  /\bFigure\s+skating\b/gi,
+  /\bFigure\s+out\b/gi,
+  /\bFigure\s+it\b/gi,
+  /\bTable\s+setting/gi,
+  /\bEquation\s+editor\b/gi,
+];
+
 /**
  * Pattern for extracting anchors from markdown: {#fig:label}, {#tbl:label}
  */
@@ -225,8 +241,7 @@ export function buildRegistry(directory, excludeFiles = ['paper.md', 'README.md'
   const sectionsPath = path.join(directory, 'sections.yaml');
   if (fs.existsSync(sectionsPath)) {
     try {
-      const yaml = require('js-yaml');
-      const config = yaml.load(fs.readFileSync(sectionsPath, 'utf-8'));
+      const config = YAML.parse(fs.readFileSync(sectionsPath, 'utf-8'));
       if (config.sections) {
         const sectionOrder = Object.entries(config.sections)
           .sort((a, b) => (a[1].order ?? 999) - (b[1].order ?? 999))

package/lib/doi.js

@@ -4,6 +4,201 @@
  */
 
 import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// ============================================================================
+// Rate Limiter - Prevents API abuse with exponential backoff
+// ============================================================================
+
+class RateLimiter {
+  constructor(options = {}) {
+    this.minDelay = options.minDelay || 100;      // Min delay between requests (ms)
+    this.maxDelay = options.maxDelay || 30000;    // Max delay after backoff (ms)
+    this.maxRetries = options.maxRetries || 3;    // Max retry attempts
+    this.backoffFactor = options.backoffFactor || 2;
+    this.lastRequestTime = 0;
+    this.currentDelay = this.minDelay;
+    this.consecutiveErrors = 0;
+  }
+
+  async wait() {
+    const now = Date.now();
+    const elapsed = now - this.lastRequestTime;
+    if (elapsed < this.currentDelay) {
+      await new Promise(r => setTimeout(r, this.currentDelay - elapsed));
+    }
+    this.lastRequestTime = Date.now();
+  }
+
+  onSuccess() {
+    // Gradually reduce delay on success
+    this.consecutiveErrors = 0;
+    this.currentDelay = Math.max(this.minDelay, this.currentDelay / this.backoffFactor);
+  }
+
+  onError(statusCode) {
+    this.consecutiveErrors++;
+    // Exponential backoff
+    if (statusCode === 429 || statusCode >= 500) {
+      this.currentDelay = Math.min(this.maxDelay, this.currentDelay * this.backoffFactor);
+    }
+    return this.consecutiveErrors <= this.maxRetries;
+  }
+
+  async fetchWithRetry(url, options = {}) {
+    let lastError;
+
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      await this.wait();
+
+      try {
+        const response = await fetch(url, options);
+
+        if (response.status === 429) {
+          // Rate limited - back off
+          const retryAfter = response.headers.get('Retry-After');
+          const delay = retryAfter ? parseInt(retryAfter, 10) * 1000 : this.currentDelay * 2;
+          this.currentDelay = Math.min(this.maxDelay, delay);
+          if (!this.onError(429)) break;
+          continue;
+        }
+
+        if (response.status >= 500 && attempt < this.maxRetries) {
+          // Server error - retry with backoff
+          if (!this.onError(response.status)) break;
+          continue;
+        }
+
+        this.onSuccess();
+        return response;
+      } catch (err) {
+        lastError = err;
+        if (!this.onError(0)) break;
+      }
+    }
+
+    throw lastError || new Error('Max retries exceeded');
+  }
+}
+
+// Shared rate limiters for different APIs
+const crossrefLimiter = new RateLimiter({ minDelay: 100, maxDelay: 10000 });
+const dataciteLimiter = new RateLimiter({ minDelay: 100, maxDelay: 10000 });
+const doiOrgLimiter = new RateLimiter({ minDelay: 200, maxDelay: 15000 });
+
+// ============================================================================
+// DOI Cache - Reduces API calls for repeated lookups
+// ============================================================================
+
+const CACHE_FILE = path.join(os.homedir(), '.rev-doi-cache.json');
+const CACHE_TTL = 7 * 24 * 60 * 60 * 1000; // 7 days in ms
+
+let doiCache = null;
+
+/**
+ * Load DOI cache from disk
+ * @returns {object}
+ */
+function loadCache() {
+  if (doiCache !== null) return doiCache;
+
+  try {
+    if (fs.existsSync(CACHE_FILE)) {
+      const data = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
+      doiCache = data;
+      return doiCache;
+    }
+  } catch {
+    // Ignore cache errors
+  }
+
+  doiCache = { entries: {}, version: 1 };
+  return doiCache;
+}
+
+/**
+ * Save DOI cache to disk
+ */
+function saveCache() {
+  if (!doiCache) return;
+
+  try {
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(doiCache, null, 2), 'utf-8');
+  } catch {
+    // Ignore cache write errors
+  }
+}
+
+/**
+ * Get cached DOI result
+ * @param {string} doi
+ * @returns {object|null}
+ */
+function getCachedDoi(doi) {
+  const cache = loadCache();
+  const entry = cache.entries[doi];
+
+  if (!entry) return null;
+
+  // Check if cache entry is expired
+  if (Date.now() - entry.timestamp > CACHE_TTL) {
+    delete cache.entries[doi];
+    return null;
+  }
+
+  return entry.result;
+}
+
+/**
+ * Cache a DOI result
+ * @param {string} doi
+ * @param {object} result
+ */
+function cacheDoi(doi, result) {
+  const cache = loadCache();
+  cache.entries[doi] = {
+    result,
+    timestamp: Date.now(),
+  };
+
+  // Limit cache size - remove oldest entries if over 1000
+  const entries = Object.entries(cache.entries);
+  if (entries.length > 1000) {
+    entries
+      .sort((a, b) => a[1].timestamp - b[1].timestamp)
+      .slice(0, entries.length - 800)
+      .forEach(([key]) => delete cache.entries[key]);
+  }
+
+  saveCache();
+}
+
+/**
+ * Clear the DOI cache
+ */
+export function clearDoiCache() {
+  doiCache = { entries: {}, version: 1 };
+  try {
+    if (fs.existsSync(CACHE_FILE)) {
+      fs.unlinkSync(CACHE_FILE);
+    }
+  } catch {
+    // Ignore
+  }
+}
+
+/**
+ * Get DOI cache statistics
+ * @returns {{ size: number, path: string }}
+ */
+export function getDoiCacheStats() {
+  const cache = loadCache();
+  return {
+    size: Object.keys(cache.entries).length,
+    path: CACHE_FILE,
+  };
+}
 
 // Entry types that typically don't have DOIs
 const NO_DOI_TYPES = new Set([
@@ -150,12 +345,15 @@ export function isValidDoiFormat(doi) {
  */
 async function checkDoiDataCite(doi) {
   try {
-    const response = await fetch(`https://api.datacite.org/dois/${encodeURIComponent(doi)}`, {
-      headers: {
-        'Accept': 'application/vnd.api+json',
-        'User-Agent': 'rev-cli/0.2.0',
-      },
-    });
+    const response = await dataciteLimiter.fetchWithRetry(
+      `https://api.datacite.org/dois/${encodeURIComponent(doi)}`,
+      {
+        headers: {
+          'Accept': 'application/vnd.api+json',
+          'User-Agent': 'docrev/0.6.0 (https://github.com/gcol33/docrev)',
+        },
+      }
+    );
 
     if (response.status === 404) {
       return { valid: false, error: 'DOI not found in DataCite' };
@@ -190,14 +388,25 @@ async function checkDoiDataCite(doi) {
 
 /**
  * Check if DOI resolves (exists) - tries Crossref first, then DataCite
+ * Results are cached for 7 days to reduce API calls.
  * @param {string} doi
- * @returns {Promise<{valid: boolean, source?: string, metadata?: object, error?: string}>}
+ * @param {object} options
+ * @param {boolean} options.skipCache - Skip cache lookup
+ * @returns {Promise<{valid: boolean, source?: string, metadata?: object, error?: string, cached?: boolean}>}
  */
-export async function checkDoi(doi) {
+export async function checkDoi(doi, options = {}) {
   if (!isValidDoiFormat(doi)) {
     return { valid: false, error: 'Invalid DOI format' };
   }
 
+  // Check cache first (unless skipped)
+  if (!options.skipCache) {
+    const cached = getCachedDoi(doi);
+    if (cached) {
+      return { ...cached, cached: true };
+    }
+  }
+
   // Zenodo DOIs start with 10.5281 - check DataCite first
   const isZenodo = doi.startsWith('10.5281/');
   const isFigshare = doi.startsWith('10.6084/');
@@ -206,37 +415,45 @@ export async function checkDoi(doi) {
   if (isDataCiteLikely) {
     const dataciteResult = await checkDoiDataCite(doi);
     if (dataciteResult.valid) {
+      cacheDoi(doi, dataciteResult);
       return dataciteResult;
     }
   }
 
   try {
     // Use Crossref API to check DOI
-    const response = await fetch(`https://api.crossref.org/works/${encodeURIComponent(doi)}`, {
-      headers: {
-        'User-Agent': 'rev-cli/0.2.0 (mailto:dev@example.com)',
-      },
-    });
+    const response = await crossrefLimiter.fetchWithRetry(
+      `https://api.crossref.org/works/${encodeURIComponent(doi)}`,
+      {
+        headers: {
+          'User-Agent': 'docrev/0.6.0 (https://github.com/gcol33/docrev; mailto:docrev@example.com)',
+        },
+      }
+    );
 
     if (response.status === 404) {
       // Try DataCite as fallback (if not already tried)
       if (!isDataCiteLikely) {
         const dataciteResult = await checkDoiDataCite(doi);
         if (dataciteResult.valid) {
+          cacheDoi(doi, dataciteResult);
           return dataciteResult;
         }
       }
-      return { valid: false, error: 'DOI not found' };
+      const result = { valid: false, error: 'DOI not found' };
+      cacheDoi(doi, result);
+      return result;
     }
 
     if (!response.ok) {
+      // Don't cache transient errors
       return { valid: false, error: `HTTP ${response.status}` };
     }
 
     const data = await response.json();
     const work = data.message;
 
-    return {
+    const result = {
       valid: true,
       source: 'crossref',
       metadata: {
@@ -247,7 +464,11 @@ export async function checkDoi(doi) {
         type: work.type,
       },
     };
+
+    cacheDoi(doi, result);
+    return result;
   } catch (err) {
+    // Don't cache network errors
     return { valid: false, error: err.message };
   }
 }
@@ -266,13 +487,16 @@ export async function fetchBibtex(doi) {
   }
 
   try {
-    const response = await fetch(`https://doi.org/${encodeURIComponent(doi)}`, {
-      headers: {
-        'Accept': 'application/x-bibtex',
-        'User-Agent': 'rev-cli/0.2.0',
-      },
-      redirect: 'follow',
-    });
+    const response = await doiOrgLimiter.fetchWithRetry(
+      `https://doi.org/${encodeURIComponent(doi)}`,
+      {
+        headers: {
+          'Accept': 'application/x-bibtex',
+          'User-Agent': 'docrev/0.6.0 (https://github.com/gcol33/docrev)',
+        },
+        redirect: 'follow',
+      }
+    );
 
     if (!response.ok) {
       return { success: false, error: `HTTP ${response.status}` };
@@ -387,12 +611,15 @@ async function searchDataCite(title, author = '', year = null) {
       'page[size]': '5',
     });
 
-    const response = await fetch(`https://api.datacite.org/dois?${params}`, {
-      headers: {
-        'Accept': 'application/vnd.api+json',
-        'User-Agent': 'rev-cli/0.2.0',
-      },
-    });
+    const response = await dataciteLimiter.fetchWithRetry(
+      `https://api.datacite.org/dois?${params}`,
+      {
+        headers: {
+          'Accept': 'application/vnd.api+json',
+          'User-Agent': 'docrev/0.6.0 (https://github.com/gcol33/docrev)',
+        },
+      }
+    );
 
     if (!response.ok) return [];
 
@@ -502,11 +729,14 @@ export async function lookupDoi(title, author = '', year = null, journal = '') {
       structuredParams.set('query.container-title', journal);
     }
 
-    let response = await fetch(`https://api.crossref.org/works?${structuredParams}`, {
-      headers: {
-        'User-Agent': 'rev-cli/0.2.0 (mailto:dev@example.com)',
-      },
-    });
+    let response = await crossrefLimiter.fetchWithRetry(
+      `https://api.crossref.org/works?${structuredParams}`,
+      {
+        headers: {
+          'User-Agent': 'docrev/0.6.0 (https://github.com/gcol33/docrev; mailto:docrev@example.com)',
+        },
+      }
+    );
 
     if (response.ok) {
       const data = await response.json();
@@ -521,11 +751,14 @@ export async function lookupDoi(title, author = '', year = null, journal = '') {
       });
       titleParams.set('query.title', title);
 
-      const response2 = await fetch(`https://api.crossref.org/works?${titleParams}`, {
-        headers: {
-          'User-Agent': 'rev-cli/0.2.0 (mailto:dev@example.com)',
-        },
-      });
+      const response2 = await crossrefLimiter.fetchWithRetry(
+        `https://api.crossref.org/works?${titleParams}`,
+        {
+          headers: {
+            'User-Agent': 'docrev/0.6.0 (https://github.com/gcol33/docrev; mailto:docrev@example.com)',
+          },
+        }
+      );
 
       if (response2.ok) {
         const data = await response2.json();
@@ -548,11 +781,14 @@ export async function lookupDoi(title, author = '', year = null, journal = '') {
         select: 'DOI,title,author,published-print,published-online,container-title,score,type',
       });
 
-      response = await fetch(`https://api.crossref.org/works?${basicParams}`, {
-        headers: {
-          'User-Agent': 'rev-cli/0.2.0 (mailto:dev@example.com)',
-        },
-      });
+      response = await crossrefLimiter.fetchWithRetry(
+        `https://api.crossref.org/works?${basicParams}`,
+        {
+          headers: {
+            'User-Agent': 'docrev/0.6.0 (https://github.com/gcol33/docrev; mailto:docrev@example.com)',
+          },
+        }
+      );
 
       if (response.ok) {
         const data = await response.json();