@ncukondo/reference-manager 0.27.2 → 0.28.1

package/dist/chunks/{index-BdLVfbj0.js → index-T-edKSzd.js}

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import { h as CslItemSchema, g as detectDuplicate, m as generateId, a as sortOrderSchema, b as sortFieldSchema, p as pickDefined, t as tokenize, s as search$1, f as sortResults, y as searchSortFieldSchema, L as Library, F as FileWatcher } from "./file-watcher-Dlx0PolG.js";
+import { h as CslItemSchema, g as detectDuplicate, m as generateId, a as sortOrderSchema, b as sortFieldSchema, p as pickDefined, t as tokenize, s as search$1, f as sortResults, y as searchSortFieldSchema, L as Library, F as FileWatcher } from "./file-watcher-CWHg1yol.js";
 import * as fs from "node:fs";
 import { mkdtempSync, writeFileSync, existsSync, readFileSync } from "node:fs";
 import { Cite, plugins } from "@citation-js/core";
@@ -10270,6 +10270,7 @@ async function fulltextDiscover(library, options) {
   if (doi) article.doi = doi;
   if (pmid) article.pmid = pmid;
   if (pmcid) article.pmcid = pmcid;
+  if (item.custom?.arxiv_id) article.arxivId = item.custom.arxiv_id;
   const config = {
     unpaywallEmail: fulltextConfig.sources.unpaywallEmail ?? "",
     coreApiKey: fulltextConfig.sources.coreApiKey ?? "",
@@ -10305,6 +10306,7 @@ function buildDiscoveryArticle(item) {
   if (item.DOI) article.doi = item.DOI;
   if (item.PMID) article.pmid = item.PMID;
   if (item.PMCID) article.pmcid = item.PMCID;
+  if (item.custom?.arxiv_id) article.arxivId = item.custom.arxiv_id;
   return article;
 }
 function buildDiscoveryConfig(fulltextConfig) {
@@ -10646,6 +10648,7 @@ function formatFirstAuthor(item) {
   if (!firstAuthor) {
     return "Unknown";
   }
+  if (firstAuthor.literal) return firstAuthor.literal;
   const family = firstAuthor.family || "Unknown";
   const givenInitial = firstAuthor.given ? firstAuthor.given[0] : "";
   if (givenInitial) {
@@ -10735,6 +10738,7 @@ function getFirstAuthorFamilyName(item) {
   if (!firstAuthor) {
     return "Unknown";
   }
+  if (firstAuthor.literal) return firstAuthor.literal;
   return firstAuthor.family || "Unknown";
 }
 function formatInTextEntry(item) {
@@ -11085,6 +11089,13 @@ function getIsbnFromCache(isbn) {
 function cacheIsbnResult(isbn, item, config) {
   storeInCache(isbnCache, isbn, item);
 }
+const arxivCache = /* @__PURE__ */ new Map();
+function getArxivFromCache(arxivId) {
+  return getFromCache(arxivCache, arxivId);
+}
+function cacheArxivResult(arxivId, item, config) {
+  storeInCache(arxivCache, arxivId, item);
+}
 const DOI_URL_PREFIXES$1 = [
   "https://doi.org/",
   "http://doi.org/",
@@ -11125,6 +11136,28 @@ function normalizeIsbn(isbn) {
   normalized = normalized.toUpperCase();
   return normalized;
 }
+const ARXIV_URL_PREFIXES = [
+  "https://arxiv.org/abs/",
+  "http://arxiv.org/abs/",
+  "https://arxiv.org/pdf/",
+  "http://arxiv.org/pdf/",
+  "https://arxiv.org/html/",
+  "http://arxiv.org/html/"
+];
+function normalizeArxiv(arxiv) {
+  const trimmed = arxiv.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const lowerInput = trimmed.toLowerCase();
+  for (const prefix of ARXIV_URL_PREFIXES) {
+    if (lowerInput.startsWith(prefix.toLowerCase())) {
+      return trimmed.slice(prefix.length);
+    }
+  }
+  const withoutPrefix = trimmed.replace(/^arxiv:\s*/i, "");
+  return withoutPrefix;
+}
 const EXTENSION_MAP = {
   ".json": "json",
   ".bib": "bibtex",
@@ -11185,6 +11218,9 @@ function detectSingleIdentifier(input) {
   if (isDoi(input)) {
     return "doi";
   }
+  if (isArxiv(input)) {
+    return "arxiv";
+  }
   if (isIsbn(input)) {
     return "isbn";
   }
@@ -11247,6 +11283,17 @@ function isIsbn(input) {
   }
   return true;
 }
+const ARXIV_ID_PATTERN = /^\d{4}\.\d{4,5}(v\d+)?$/;
+function isArxiv(input) {
+  if (!input || input.length === 0) {
+    return false;
+  }
+  const normalized = normalizeArxiv(input);
+  if (!normalized) {
+    return false;
+  }
+  return ARXIV_ID_PATTERN.test(normalized);
+}
 const RATE_LIMITS = {
   pubmed: {
     withoutApiKey: 3,
@@ -11256,8 +11303,10 @@ const RATE_LIMITS = {
   },
   crossref: 50,
   // 50 req/sec
-  isbn: 10
+  isbn: 10,
   // 10 req/sec (conservative for Google Books API daily limit)
+  arxiv: 1
+  // 1 req/sec (arXiv API is strict about rate limiting)
 };
 class RateLimiterImpl {
   requestsPerSecond;
@@ -11310,6 +11359,8 @@ function getRequestsPerSecond(api, config) {
       return RATE_LIMITS.crossref;
     case "isbn":
       return RATE_LIMITS.isbn;
+    case "arxiv":
+      return RATE_LIMITS.arxiv;
   }
 }
 const PMC_API_BASE = "https://pmc.ncbi.nlm.nih.gov/api/ctxp/v1/pubmed/";
@@ -11489,8 +11540,108 @@ async function fetchIsbn(isbn) {
     };
   }
 }
+const ARXIV_API_BASE = "https://export.arxiv.org/api/query";
+function extractXmlText(xml, tagName) {
+  const regex = new RegExp(`<${tagName}[^>]*>([\\s\\S]*?)</${tagName}>`);
+  const match = regex.exec(xml);
+  return match?.[1]?.trim() ?? "";
+}
+function extractAuthors(entryXml) {
+  const authors = [];
+  const matches = entryXml.matchAll(/<author>[\s\S]*?<name>([^<]+)<\/name>[\s\S]*?<\/author>/g);
+  for (const match of matches) {
+    const name = match[1]?.trim();
+    if (name) {
+      authors.push({ literal: name });
+    }
+  }
+  return authors;
+}
+function extractJournalDoi(entryXml) {
+  const match = /<arxiv:doi[^>]*>([^<]+)<\/arxiv:doi>/.exec(entryXml);
+  return match?.[1]?.trim();
+}
+function parseIssuedDate(dateStr) {
+  if (!dateStr) return void 0;
+  const date = new Date(dateStr);
+  if (Number.isNaN(date.getTime())) return void 0;
+  return {
+    "date-parts": [[date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate()]]
+  };
+}
+async function fetchArxiv(arxivId) {
+  if (!ARXIV_ID_PATTERN.test(arxivId)) {
+    return {
+      success: false,
+      error: `Invalid arXiv ID format: ${arxivId}`,
+      reason: "validation_error"
+    };
+  }
+  const rateLimiter = getRateLimiter("arxiv", {});
+  await rateLimiter.acquire();
+  try {
+    const url = `${ARXIV_API_BASE}?id_list=${encodeURIComponent(arxivId)}`;
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      return {
+        success: false,
+        error: `arXiv API returned status ${response.status}`,
+        reason: "fetch_error"
+      };
+    }
+    const xml = await response.text();
+    const entryMatch = /<entry>([\s\S]*?)<\/entry>/.exec(xml);
+    if (!entryMatch) {
+      return {
+        success: false,
+        error: `No results found for arXiv ID ${arxivId}`,
+        reason: "not_found"
+      };
+    }
+    const entryXml = entryMatch[1] ?? "";
+    const title = extractXmlText(entryXml, "title");
+    const summary = extractXmlText(entryXml, "summary");
+    const published = extractXmlText(entryXml, "published");
+    const authors = extractAuthors(entryXml);
+    const journalDoi = extractJournalDoi(entryXml);
+    const baseId = arxivId.replace(/v\d+$/, "");
+    const doi = journalDoi ?? `10.48550/arXiv.${baseId}`;
+    const item = {
+      id: "",
+      type: "article",
+      title,
+      author: authors,
+      abstract: summary || void 0,
+      issued: parseIssuedDate(published),
+      DOI: doi,
+      URL: `https://arxiv.org/abs/${arxivId}`,
+      custom: {
+        arxiv_id: arxivId
+      }
+    };
+    const parseResult = CslItemSchema.safeParse(item);
+    if (!parseResult.success) {
+      return {
+        success: false,
+        error: `Invalid CSL-JSON data for arXiv ${arxivId}: ${parseResult.error.message}`,
+        reason: "validation_error"
+      };
+    }
+    return { success: true, item: parseResult.data };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: errorMsg,
+      reason: "fetch_error"
+    };
+  }
+}
 const fetcher = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  fetchArxiv,
   fetchDoi,
   fetchIsbn,
   fetchPmids
@@ -11685,19 +11836,22 @@ function classifyIdentifiers(identifiers) {
   const pmids = [];
   const dois = [];
   const isbns = [];
+  const arxivs = [];
   const unknowns = [];
   for (const id of identifiers) {
-    if (isPmid(id)) {
-      pmids.push(normalizePmid(id));
-    } else if (isDoi(id)) {
+    if (isDoi(id)) {
       dois.push(normalizeDoi(id));
+    } else if (isArxiv(id)) {
+      arxivs.push(normalizeArxiv(id));
     } else if (isIsbn(id)) {
       isbns.push(normalizeIsbn(id));
+    } else if (isPmid(id)) {
+      pmids.push(normalizePmid(id));
     } else {
       unknowns.push(id);
     }
   }
-  return { pmids, dois, isbns, unknowns };
+  return { pmids, dois, isbns, arxivs, unknowns };
 }
 function buildUnknownResults(unknowns) {
   return unknowns.map((unknown) => ({
@@ -11790,6 +11944,29 @@ async function fetchIsbnsWithCache(isbns) {
   }
   return results;
 }
+async function fetchArxivsWithCache(arxivIds) {
+  const results = [];
+  for (const arxivId of arxivIds) {
+    const cached = getArxivFromCache(arxivId);
+    if (cached) {
+      results.push({ success: true, item: clearItemId(cached), source: arxivId });
+      continue;
+    }
+    const fetchResult = await fetchArxiv(arxivId);
+    if (fetchResult.success) {
+      cacheArxivResult(arxivId, fetchResult.item);
+      results.push({ success: true, item: clearItemId(fetchResult.item), source: arxivId });
+    } else {
+      results.push({
+        success: false,
+        error: fetchResult.error,
+        source: arxivId,
+        reason: fetchResult.reason
+      });
+    }
+  }
+  return results;
+}
 function parseJsonContent(content) {
   try {
     const parsed = JSON.parse(content);
@@ -11946,7 +12123,7 @@ async function importFromIdentifiers(identifiers, options) {
   if (identifiers.length === 0) {
     return { results: [] };
   }
-  const { pmids, dois, isbns, unknowns } = classifyIdentifiers(identifiers);
+  const { pmids, dois, isbns, arxivs, unknowns } = classifyIdentifiers(identifiers);
   const results = [];
   results.push(...buildUnknownResults(unknowns));
   const pmidResults = await fetchPmidsWithCache(pmids, options.pubmedConfig ?? {});
@@ -11955,6 +12132,8 @@ async function importFromIdentifiers(identifiers, options) {
   results.push(...doiResults);
   const isbnResults = await fetchIsbnsWithCache(isbns);
   results.push(...isbnResults);
+  const arxivResults = await fetchArxivsWithCache(arxivs);
+  results.push(...arxivResults);
   return { results };
 }
 function looksLikeFilePath(input) {
@@ -11996,13 +12175,14 @@ async function processIdentifiers(inputs, options) {
     const isValidPmid = isPmid(input);
     const isValidDoi = isDoi(input);
     const isValidIsbn = isIsbn(input);
-    if (isValidPmid || isValidDoi || isValidIsbn) {
+    const isValidArxiv = isArxiv(input);
+    if (isValidPmid || isValidDoi || isValidIsbn || isValidArxiv) {
       validIdentifiers.push(input);
     } else {
       const hint = looksLikeFilePath(input) ? " Hint: If this is a file path, check that the file exists." : "";
       results.push({
         success: false,
-        error: `Cannot interpret '${input}' as identifier (not a valid PMID, DOI, or ISBN).${hint}`,
+        error: `Cannot interpret '${input}' as identifier (not a valid PMID, DOI, ISBN, or arXiv ID).${hint}`,
         source: input,
         reason: "validation_error"
       });
@@ -12046,7 +12226,7 @@ async function processStdinContent(content, options) {
       source: r.source === "content" ? "stdin" : r.source
     }));
   }
-  if (format === "pmid" || format === "doi" || format === "isbn") {
+  if (format === "pmid" || format === "doi" || format === "isbn" || format === "arxiv") {
     const identifiers2 = content.split(/\s+/).filter((s) => s.length > 0);
     return processIdentifiers(identifiers2, options);
   }
@@ -12219,7 +12399,7 @@ function createAddRoute(library, config) {
 }
 const CHECK_CONCURRENCY = 5;
 async function checkReferences(library, options) {
-  const { checkReference } = await import("./checker-gLAPe44T.js");
+  const { checkReference } = await import("./checker-CP8vSC-S.js");
   const save = options.save !== false;
   const skipDays = options.skipDays ?? 7;
   const items = await resolveItems(library, options);
@@ -12249,7 +12429,7 @@ function fillSkippedResults(tasks, results) {
         uuid: task.item.custom?.uuid ?? "",
         status: "skipped",
         findings: [],
-        checkedAt: task.item.custom?.check?.checked_at,
+        checkedAt: task.item.custom?.check?.checked_at ?? "",
         checkedSources: []
       };
     }
@@ -12311,11 +12491,11 @@ async function resolveItems(library, options) {
 }
 function shouldSkipRecentCheck(item, skipDays) {
   if (skipDays <= 0) return false;
-  const check2 = item.custom?.check;
-  if (!check2?.checked_at) return false;
-  const checkedAt = new Date(check2.checked_at);
+  const checkedAt = item.custom?.check?.checked_at;
+  if (!checkedAt) return false;
+  const checkedAtDate = new Date(checkedAt);
   const now = /* @__PURE__ */ new Date();
-  const daysSince = (now.getTime() - checkedAt.getTime()) / (1e3 * 60 * 60 * 24);
+  const daysSince = (now.getTime() - checkedAtDate.getTime()) / (1e3 * 60 * 60 * 24);
   return daysSince < skipDays;
 }
 async function saveCheckResult(library, item, result) {
@@ -12328,9 +12508,8 @@ async function saveCheckResult(library, item, result) {
       ...f.details ? { details: snakeCaseKeys(f.details) } : {}
     }))
   };
-  const existingCustom = item.custom ?? {};
   await library.update(item.id, {
-    custom: { ...existingCustom, check: checkData }
+    custom: { ...item.custom, check: checkData }
   });
 }
 function snakeCaseKeys(obj) {
@@ -12899,4 +13078,4 @@ export {
   fetcher as y,
   add as z
 };
-//# sourceMappingURL=index-BdLVfbj0.js.map
+//# sourceMappingURL=index-T-edKSzd.js.map