dsh-paper-search 0.1.0

package/lib/sources.js

@@ -0,0 +1,576 @@
+// lib/sources.js — konektor sumber literatur untuk dsh-paper-search.
+//
+// DUA JENIS SUMBER, dan bedanya penting (jangan disamarkan):
+//
+//   kind: 'api'  — REST API publik yang mengembalikan JSON. Stabil, ada skema.
+//   kind: 'html' — halaman web publik yang HARUS diurai. Rapuh menurut sifatnya:
+//                  operator bisa mengubah markup kapan saja dan pengurai ini
+//                  akan mengembalikan 0 hasil. Karena itu kegagalannya WAJIB
+//                  dilaporkan apa adanya (lihat `searchSource`), bukan diubah
+//                  menjadi "tidak ada hasil".
+//
+// ATURAN YANG DIPAKAI SELURUH BERKAS INI: kegagalan tidak boleh menyamar jadi
+// kekosongan. Semua non-2xx melempar error beserta status dan cuplikan body;
+// `searchSource` menangkapnya dan mengembalikannya sebagai `error`, terpisah
+// dari `papers`. Ini pelajaran dari `paper-search-mcp` upstream, yang
+// mengembalikan `[]` untuk SETIAP status != 200 tanpa jejak — sehingga arXiv
+// yang menjawab 406 tampak seperti "tidak ada paper".
+
+const UA = 'dsh-paper-search/0.1 (+https://github.com/rasyidmmz/dsh-paper-search)';
+const TIMEOUT_MS = 25000;
+
+// ── HTTP ─────────────────────────────────────────────────────────────────────
+
+async function getText(url, { headers = {}, accept, timeoutMs = TIMEOUT_MS } = {}) {
+  const ctl = new AbortController();
+  const jam = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      redirect: 'follow',
+      signal: ctl.signal,
+      headers: { 'User-Agent': UA, ...(accept ? { Accept: accept } : {}), ...headers },
+    });
+    const teks = await res.text();
+    if (!res.ok) {
+      const err = new Error(`HTTP ${res.status}`);
+      err.status = res.status;
+      err.body = teks.slice(0, 160).replace(/\s+/g, ' ');
+      throw err;
+    }
+    return teks;
+  } finally {
+    clearTimeout(jam);
+  }
+}
+
+async function getJson(url, opts) {
+  return JSON.parse(await getText(url, { ...opts, accept: 'application/json' }));
+}
+
+// ── Bentuk hasil seragam ─────────────────────────────────────────────────────
+
+const ENTITAS = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ' };
+
+function bersihTeks(s) {
+  if (!s) return null;
+  return String(s)
+    .replace(/<[^>]*>/g, ' ')
+    .replace(/&(#\d+|[a-z]+);/gi, (m, k) => ENTITAS[k.toLowerCase()] ?? (k[0] === '#' ? String.fromCharCode(Number(k.slice(1))) : m))
+    .replace(/\s+/g, ' ')
+    .trim() || null;
+}
+
+function potong(s, n) {
+  const t = bersihTeks(s);
+  if (!t) return null;
+  return t.length > n ? `${t.slice(0, n - 1)}…` : t;
+}
+
+/** DOI dinormalkan tanpa awalan URL — supaya dedup bekerja. */
+function normDoi(doi) {
+  if (!doi) return null;
+  const d = String(doi).trim().replace(/^https?:\/\/(dx\.)?doi\.org\//i, '').replace(/^doi:\s*/i, '');
+  return d.length > 3 ? d.toLowerCase() : null;
+}
+
+/**
+ * Beberapa portal menulis judul di dalam elemen <xmp> dan MENGULANGNYA untuk
+ * mengisi lebar tampilan. Terukur di Garuda 28 Sep 2026: judul
+ * "PENDIDIKAN KARAKTER ANAK USIA SEKOLAH DASAR" (44 huruf) muncul sekitar enam
+ * kali dalam satu <xmp> sehingga panjangnya 255 huruf.
+ *
+ * Fungsi ini mencari periode terkecil dan menyisakan SATU salinan. Ia hanya
+ * bertindak bila pengulangannya PERSIS dari awal sampai akhir — kalau tidak,
+ * teks dibiarkan apa adanya. Sengaja konservatif: lebih baik judul berlebihan
+ * daripada judul yang terpotong salah.
+ */
+function runtuhkanPeriodik(s) {
+  const t = (s ?? '').trim();
+  const n = t.length;
+  if (n < 30) return t;
+  for (let p = 10; p <= Math.floor(n / 2); p++) {
+    let cocok = true;
+    for (let i = p; i < n; i++) {
+      if (t[i] !== t[i % p]) { cocok = false; break; }
+    }
+    if (cocok) return t.slice(0, p).trim();
+  }
+  return t;
+}
+
+function buatPaper(p) {
+  const doi = normDoi(p.doi);
+  return {
+    title: potong(runtuhkanPeriodik(bersihTeks(p.title) ?? ''), 300),
+    authors: Array.isArray(p.authors) ? p.authors.map(bersihTeks).filter(Boolean).slice(0, 15) : [],
+    year: Number.isFinite(Number(p.year)) && Number(p.year) > 1500 ? Number(p.year) : null,
+    source: p.source,
+    doi,
+    url: p.url || (doi ? `https://doi.org/${doi}` : null),
+    journal: bersihTeks(p.journal),
+    abstract: potong(p.abstract, 900),
+    openAccess: !!p.openAccess,
+  };
+}
+
+// ── Sumber INTERNASIONAL (API JSON) ──────────────────────────────────────────
+
+async function crossref(query, { rows, email }) {
+  const u = new URL('https://api.crossref.org/works');
+  u.searchParams.set('query', query);
+  u.searchParams.set('rows', String(rows));
+  u.searchParams.set('select', 'DOI,title,container-title,author,issued,abstract,URL');
+  if (email) u.searchParams.set('mailto', email);
+  const j = await getJson(u.toString());
+  return (j?.message?.items ?? []).map((it) => buatPaper({
+    title: it.title?.[0],
+    authors: (it.author ?? []).map((a) => [a.given, a.family].filter(Boolean).join(' ') || a.name),
+    year: it.issued?.['date-parts']?.[0]?.[0],
+    source: 'crossref',
+    doi: it.DOI,
+    url: it.URL,
+    journal: it['container-title']?.[0],
+    abstract: it.abstract,
+  })).filter((p) => p.title);
+}
+
+/** OpenAlex menyimpan abstrak sebagai indeks terbalik — harus disusun ulang. */
+function abstrakOpenAlex(inv) {
+  if (!inv || typeof inv !== 'object') return null;
+  const pos = [];
+  for (const [kata, idxs] of Object.entries(inv)) for (const i of idxs) pos[i] = kata;
+  return pos.filter(Boolean).join(' ') || null;
+}
+
+async function openalex(query, { rows, email }) {
+  const u = new URL('https://api.openalex.org/works');
+  u.searchParams.set('search', query);
+  u.searchParams.set('per-page', String(rows));
+  if (email) u.searchParams.set('mailto', email);
+  const j = await getJson(u.toString());
+  return (j?.results ?? []).map((w) => buatPaper({
+    title: w.title,
+    authors: (w.authorships ?? []).map((a) => a.author?.display_name),
+    year: w.publication_year,
+    source: 'openalex',
+    doi: w.doi,
+    url: w.doi || w.id,
+    journal: w.primary_location?.source?.display_name,
+    abstract: abstrakOpenAlex(w.abstract_inverted_index),
+    openAccess: !!w.open_access?.is_oa,
+  })).filter((p) => p.title);
+}
+
+async function doaj(query, { rows }) {
+  // Query DOAJ ada di PATH, bukan query string.
+  const j = await getJson(`https://doaj.org/api/search/articles/${encodeURIComponent(query)}?pageSize=${rows}`);
+  return (j?.results ?? []).map((r) => {
+    const b = r.bibjson ?? {};
+    return buatPaper({
+      title: b.title,
+      authors: (b.author ?? []).map((a) => a.name),
+      year: b.year,
+      source: 'doaj',
+      doi: (b.identifier ?? []).find((x) => x.type === 'doi')?.id,
+      url: (b.link ?? []).find((x) => x.type === 'fulltext')?.url,
+      journal: b.journal?.title,
+      abstract: b.abstract,
+      openAccess: true,
+    });
+  }).filter((p) => p.title);
+}
+
+async function europepmc(query, { rows }) {
+  const u = `https://www.ebi.ac.uk/europepmc/webservices/rest/search?query=${encodeURIComponent(query)}&format=json&pageSize=${rows}`;
+  const j = await getJson(u);
+  return (j?.resultList?.result ?? []).map((r) => buatPaper({
+    title: r.title,
+    authors: r.authorString ? r.authorString.split(/,\s*/) : [],
+    year: r.pubYear,
+    source: 'europepmc',
+    doi: r.doi,
+    url: r.doi ? `https://doi.org/${r.doi}` : `https://europepmc.org/article/${r.source ?? 'MED'}/${r.id}`,
+    journal: r.journalTitle,
+    abstract: r.abstractText,
+    openAccess: r.isOpenAccess === 'Y',
+  })).filter((p) => p.title);
+}
+
+async function pubmed(query, { rows }) {
+  // E-utilities butuh DUA panggilan: esearch (id) lalu esummary (metadata).
+  const base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils';
+  const s = await getJson(`${base}/esearch.fcgi?db=pubmed&retmode=json&retmax=${rows}&term=${encodeURIComponent(query)}`);
+  const ids = s?.esearchresult?.idlist ?? [];
+  if (ids.length === 0) return [];
+  const d = await getJson(`${base}/esummary.fcgi?db=pubmed&retmode=json&id=${ids.join(',')}`);
+  return ids.map((id) => {
+    const r = d?.result?.[id];
+    if (!r) return null;
+    return buatPaper({
+      title: r.title,
+      authors: (r.authors ?? []).map((a) => a.name),
+      year: String(r.pubdate ?? '').slice(0, 4),
+      source: 'pubmed',
+      doi: (r.articleids ?? []).find((a) => a.idtype === 'doi')?.value,
+      url: `https://pubmed.ncbi.nlm.nih.gov/${id}/`,
+      journal: r.fulljournalname || r.source,
+    });
+  }).filter((p) => p && p.title);
+}
+
+// arXiv meminta TIDAK LEBIH dari 1 permintaan / 3 detik (TOU mereka). Karena
+// sumber dijalankan paralel, permintaan arXiv diserialkan sendiri di sini.
+let arxivTerakhir = 0;
+async function arxiv(query, { rows }) {
+  const jeda = 3000 - (Date.now() - arxivTerakhir);
+  if (jeda > 0) await new Promise((r) => setTimeout(r, jeda));
+  try {
+    const u = `https://export.arxiv.org/api/query?search_query=${encodeURIComponent(`all:${query}`)}&max_results=${rows}&sortBy=relevance`;
+    const xml = await getText(u, { accept: 'application/atom+xml' });
+    const out = [];
+    for (const m of xml.matchAll(/<entry>([\s\S]*?)<\/entry>/g)) {
+      const blok = m[1];
+      const ambil = (tag) => {
+        const r = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`).exec(blok);
+        return r ? r[1] : null;
+      };
+      out.push(buatPaper({
+        title: ambil('title'),
+        authors: [...blok.matchAll(/<author>\s*<name>([^<]+)<\/name>/g)].map((x) => x[1]),
+        year: String(ambil('published') ?? '').slice(0, 4),
+        source: 'arxiv',
+        doi: ambil('arxiv:doi'),
+        url: ambil('id'),
+        journal: 'arXiv (preprint)',
+        abstract: ambil('summary'),
+        openAccess: true,
+      }));
+    }
+    return out.filter((p) => p.title);
+  } finally {
+    arxivTerakhir = Date.now();
+  }
+}
+
+async function semantic(query, { rows, apiKey }) {
+  const u = `https://api.semanticscholar.org/graph/v1/paper/search?query=${encodeURIComponent(query)}&limit=${rows}&fields=title,year,authors,externalIds,venue,abstract,openAccessPdf`;
+  const j = await getJson(u, apiKey ? { headers: { 'x-api-key': apiKey } } : {});
+  return (j?.data ?? []).map((d) => buatPaper({
+    title: d.title,
+    authors: (d.authors ?? []).map((a) => a.name),
+    year: d.year,
+    source: 'semantic',
+    doi: d.externalIds?.DOI,
+    url: d.openAccessPdf?.url || (d.externalIds?.DOI ? `https://doi.org/${d.externalIds.DOI}` : null),
+    journal: d.venue,
+    abstract: d.abstract,
+    openAccess: !!d.openAccessPdf,
+  })).filter((p) => p.title);
+}
+
+/** Beberapa API mengembalikan medan yang bisa berupa nilai tunggal ATAU array. */
+function pertama(x) {
+  return Array.isArray(x) ? x[0] : x;
+}
+
+async function pmc(query, { rows }) {
+  // PubMed Central memakai E-utilities yang sama dengan PubMed:
+  // esearch (id) lalu esummary (metadata).
+  const base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils';
+  const s = await getJson(`${base}/esearch.fcgi?db=pmc&retmode=json&retmax=${rows}&term=${encodeURIComponent(query)}`);
+  const ids = s?.esearchresult?.idlist ?? [];
+  if (ids.length === 0) return [];
+  const d = await getJson(`${base}/esummary.fcgi?db=pmc&retmode=json&id=${ids.join(',')}`);
+  return ids.map((id) => {
+    const r = d?.result?.[id];
+    if (!r) return null;
+    const pmcid = (r.articleids ?? []).find((a) => a.idtype === 'pmcid')?.value ?? `PMC${id}`;
+    return buatPaper({
+      title: r.title,
+      authors: (r.authors ?? []).map((a) => a.name),
+      year: String(r.pubdate ?? '').slice(0, 4),
+      source: 'pmc',
+      doi: (r.articleids ?? []).find((a) => a.idtype === 'doi')?.value,
+      url: `https://www.ncbi.nlm.nih.gov/pmc/articles/${pmcid}/`,
+      journal: r.fulljournalname || r.source,
+      openAccess: true,
+    });
+  }).filter((p) => p && p.title);
+}
+
+async function core(query, { rows, coreApiKey }) {
+  // CORE TIDAK bisa dipakai tanpa kunci: terukur 28 Sep 2026, permintaan tanpa
+  // `Bearer` dijawab HTTP 429 dengan body KOSONG — bukan 401. Karena itu kunci
+  // yang hilang dilaporkan sebagai pesan yang bisa ditindaklanjuti, bukan
+  // dibiarkan menjadi 429 yang membingungkan.
+  if (!coreApiKey) {
+    throw new Error('butuh CORE_API_KEY — tanpa kunci CORE menjawab HTTP 429 dengan body kosong');
+  }
+  const j = await getJson(`https://api.core.ac.uk/v3/search/works?q=${encodeURIComponent(query)}&limit=${rows}`, {
+    headers: { Authorization: `Bearer ${coreApiKey}` },
+  });
+  return (j?.results ?? []).map((c) => buatPaper({
+    title: c.title,
+    authors: (c.authors ?? []).map((a) => a.name),
+    year: c.yearPublished,
+    source: 'core',
+    doi: c.doi,
+    url: c.downloadUrl || (c.doi ? `https://doi.org/${c.doi}` : null),
+    journal: c.publisher,
+    abstract: c.abstract,
+    openAccess: !!c.downloadUrl,
+  })).filter((p) => p.title);
+}
+
+async function zenodo(query, { rows }) {
+  const j = await getJson(`https://zenodo.org/api/records?q=${encodeURIComponent(query)}&size=${rows}`);
+  return (j?.hits?.hits ?? []).map((z) => buatPaper({
+    title: z.metadata?.title,
+    authors: (z.metadata?.creators ?? []).map((c) => c.name),
+    year: String(z.metadata?.publication_date ?? '').slice(0, 4),
+    source: 'zenodo',
+    doi: z.metadata?.doi ?? z.doi,
+    url: z.links?.self_html ?? z.links?.self,
+    journal: z.metadata?.imprint?.publisher ?? 'Zenodo',
+    abstract: z.metadata?.description,
+    openAccess: true,
+  })).filter((p) => p.title);
+}
+
+async function hal(query, { rows }) {
+  const fl = 'title_s,authFullName_s,producedDateY_i,doiId_s,uri_s,journalTitle_s,abstract_s';
+  const j = await getJson(`https://api.archives-ouvertes.fr/search/?q=${encodeURIComponent(query)}&wt=json&rows=${rows}&fl=${fl}`);
+  return (j?.response?.docs ?? []).map((a) => buatPaper({
+    title: pertama(a.title_s),
+    authors: a.authFullName_s ?? [],
+    year: a.producedDateY_i,
+    source: 'hal',
+    doi: pertama(a.doiId_s),
+    url: pertama(a.uri_s),
+    journal: pertama(a.journalTitle_s),
+    abstract: pertama(a.abstract_s),
+    openAccess: true,
+  })).filter((p) => p.title);
+}
+
+/** IACR Cryptology ePrint Archive — arsip pra-cetak kriptologi (HTML). */
+async function iacr(query, { rows }) {
+  const html = await getText(`https://eprint.iacr.org/search?q=${encodeURIComponent(query)}`, { headers: { 'User-Agent': UA_BROWSER } });
+  const tautan = [...html.matchAll(/<a title="(\d{4}\/\d+)" class="paperlink" href="\/(\d{4}\/\d+)"/g)];
+  if (tautan.length === 0) {
+    if (!/class="paperlink"/.test(html)) throw new Error('markup IACR berubah: tautan ber-class "paperlink" tidak ditemukan lagi');
+    return [];
+  }
+  const out = [];
+  for (let i = 0; i < tautan.length && out.length < rows; i++) {
+    // Potong per hasil memakai posisi tautan berikutnya sebagai batas, supaya
+    // regex tidak menyeberang ke hasil lain.
+    const blok = html.slice(tautan[i].index, i + 1 < tautan.length ? tautan[i + 1].index : html.length);
+    const ambil = (re) => { const m = re.exec(blok); return m ? m[1] : null; };
+    const id = tautan[i][1];
+    out.push(buatPaper({
+      title: ambil(/<strong>([\s\S]*?)<\/strong>/),
+      authors: (ambil(/<span class="fst-italic">([\s\S]*?)<\/span>/) ?? '').split(/,\s*/).filter(Boolean),
+      year: id.slice(0, 4),
+      source: 'iacr',
+      url: `https://eprint.iacr.org/${id}`,
+      journal: 'IACR Cryptology ePrint Archive',
+      abstract: ambil(/<p class="mb-0 mt-1 search-abstract">([\s\S]*?)<\/p>/),
+      openAccess: true,
+    }));
+  }
+  return out.filter((p) => p.title);
+}
+
+/**
+ * Unpaywall — pencari akses-terbuka **berdasarkan DOI**, BUKAN pencari kata
+ * kunci. Diverifikasi 28 Sep 2026: dengan DOI ia menjawab HTTP 200 dan
+ * menemukan papernya; dengan kata kunci ia memang mengembalikan 0.
+ *
+ * Query yang bukan DOI dikembalikan KOSONG TANPA error — itu bukan kegagalan,
+ * itu memang cara kerjanya. Kalau ini dilempar sebagai error, setiap pencarian
+ * kata kunci akan menulis baris GAGAL palsu.
+ */
+async function unpaywall(query, { rows, email }) {
+  const doi = normDoi(query);
+  if (!doi) return [];
+  if (!email) throw new Error('butuh UNPAYWALL_EMAIL — Unpaywall menolak permintaan tanpa email');
+  const j = await getJson(`https://api.unpaywall.org/v2/${encodeURIComponent(doi)}?email=${encodeURIComponent(email)}`);
+  if (!j?.title) return [];
+  const oa = j.best_oa_location ?? null;
+  const hasil = buatPaper({
+    title: j.title,
+    authors: (j.z_authors ?? []).map((a) => a.raw_author_name ?? [a.given, a.family].filter(Boolean).join(' ')),
+    year: j.year,
+    source: 'unpaywall',
+    doi: j.doi ?? doi,
+    url: oa?.url_for_pdf ?? oa?.url ?? (j.doi ? `https://doi.org/${j.doi}` : null),
+    journal: j.journal_name,
+    openAccess: !!j.is_oa,
+  });
+  return hasil.title ? [hasil].slice(0, Math.max(1, Math.min(rows, 1))) : [];
+}
+
+// ── Sumber INDONESIA (penguraian HTML) ───────────────────────────────────────
+//
+// Pola di bawah DIUKUR langsung dari halaman hidupnya (28 Sep 2026), bukan
+// ditebak. Kalau operator mengubah markup, sumbernya akan melaporkan 0 hasil —
+// dan itu akan terlihat, bukan tersamar, karena kita pisahkan `error` dari
+// `papers` (lihat `searchSource`).
+
+const UA_BROWSER = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0 Safari/537.36';
+
+function ambilHtml(html, pola, batas) {
+  const out = [];
+  for (const m of html.matchAll(pola)) {
+    if (out.length >= batas) break;
+    out.push(m);
+  }
+  return out;
+}
+
+const GARUDA_BASE = 'https://garuda.kemdiktisaintek.go.id';
+
+/** Garuda — indeks artikel jurnal Indonesia (Kemdiktisaintek). */
+async function garuda(query, { rows }) {
+  const html = await getText(`${GARUDA_BASE}/documents?q=${encodeURIComponent(query)}`, { headers: { 'User-Agent': UA_BROWSER } });
+  const pola = /<a[^>]*class="title-article"[^>]*href="\/documents\/detail\/(\d+)"[^>]*>\s*<xmp>([\s\S]*?)<\/xmp>/g;
+  const hasil = ambilHtml(html, pola, rows).map((m) => buatPaper({
+    title: m[2],
+    source: 'garuda',
+    url: `${GARUDA_BASE}/documents/detail/${m[1]}`,
+    journal: 'Garuda (jurnal Indonesia)',
+    openAccess: true,
+  })).filter((p) => p.title);
+  // Penguraian HTML yang tidak menemukan satu pun pola = kemungkinan markup
+  // berubah. Laporkan sebagai error, JANGAN sebagai "tidak ada hasil".
+  if (hasil.length === 0 && !/title-article/.test(html)) {
+    throw new Error('markup Garuda berubah: penanda "title-article" tidak ditemukan lagi');
+  }
+  return hasil;
+}
+
+/** Sinta — daftar JURNAL Indonesia terakreditasi (bukan artikel). */
+async function sinta(query, { rows }) {
+  const html = await getText(`https://sinta.kemdiktisaintek.go.id/journals?q=${encodeURIComponent(query)}`, { headers: { 'User-Agent': UA_BROWSER } });
+  const pola = /href="https:\/\/sinta\.kemdiktisaintek\.go\.id\/journals\/profile\/(\d+)"[^>]*>([\s\S]{3,220}?)<\/a>/g;
+  const hasil = ambilHtml(html, pola, rows).map((m) => buatPaper({
+    title: m[2],
+    source: 'sinta',
+    url: `https://sinta.kemdiktisaintek.go.id/journals/profile/${m[1]}`,
+    journal: 'Sinta (jurnal terakreditasi)',
+    openAccess: true,
+  })).filter((p) => p.title);
+  if (hasil.length === 0 && !/journals\/profile\//.test(html)) {
+    throw new Error('markup Sinta berubah: tautan "journals/profile" tidak ditemukan lagi');
+  }
+  return hasil;
+}
+
+/** IOS OneSearch — agregator repositori Indonesia (Perpusnas). */
+async function ios(query, { rows }) {
+  const html = await getText(`https://onesearch.id/Search/Results?lookfor=${encodeURIComponent(query)}&type=AllFields`, { headers: { 'User-Agent': UA_BROWSER } });
+  const pola = /<a[^>]*href="\/Record\/([^"]+)"[^>]*class="title"[^>]*>([\s\S]*?)<\/a>/g;
+  const hasil = ambilHtml(html, pola, rows).map((m) => buatPaper({
+    title: m[2],
+    source: 'ios',
+    url: `https://onesearch.id/Record/${m[1]}`,
+    journal: 'IOS OneSearch (repositori Indonesia)',
+    openAccess: true,
+  })).filter((p) => p.title);
+  if (hasil.length === 0 && !/class="title"/.test(html)) {
+    throw new Error('markup IOS berubah: tautan hasil ber-class "title" tidak ditemukan lagi');
+  }
+  return hasil;
+}
+
+// ── Registry ─────────────────────────────────────────────────────────────────
+
+export const SUMBER = [
+  // Internasional
+  { id: 'crossref', label: 'Crossref', region: 'international', kind: 'api', credit: 'disarankan (polite pool)', fn: crossref },
+  { id: 'openalex', label: 'OpenAlex', region: 'international', kind: 'api', credit: 'disarankan (polite pool)', fn: openalex },
+  { id: 'doaj', label: 'DOAJ', region: 'international', kind: 'api', credit: 'opsional', fn: doaj, catatan: 'mencakup jurnal akses-terbuka Indonesia juga' },
+  { id: 'europepmc', label: 'Europe PMC', region: 'international', kind: 'api', credit: null, fn: europepmc },
+  { id: 'pubmed', label: 'PubMed', region: 'international', kind: 'api', credit: null, fn: pubmed, catatan: 'dua panggilan per pencarian (esearch + esummary)' },
+  { id: 'arxiv', label: 'arXiv', region: 'international', kind: 'api', credit: null, fn: arxiv, catatan: 'preprint; dibatasi sendiri 1 permintaan / 3 detik' },
+  { id: 'semantic', label: 'Semantic Scholar', region: 'international', kind: 'api', credit: 'menaikkan batas laju', fn: semantic },
+  { id: 'pmc', label: 'PubMed Central', region: 'international', kind: 'api', credit: null, fn: pmc, catatan: 'teks penuh akses-terbuka; dua panggilan per pencarian' },
+  { id: 'core', label: 'CORE', region: 'international', kind: 'api', credit: 'WAJIB — tanpa kunci balas 429', fn: core, catatan: 'agregator repositori akses-terbuka' },
+  { id: 'zenodo', label: 'Zenodo', region: 'international', kind: 'api', credit: null, fn: zenodo, catatan: 'repositori umum: data, perangkat lunak, preprint' },
+  { id: 'hal', label: 'HAL', region: 'international', kind: 'api', credit: null, fn: hal, catatan: 'repositori akses-terbuka Prancis' },
+  { id: 'iacr', label: 'IACR ePrint', region: 'international', kind: 'html', credit: null, fn: iacr, catatan: 'arsip pra-cetak kriptologi' },
+  { id: 'unpaywall', label: 'Unpaywall', region: 'international', kind: 'api', input: 'doi', credit: 'WAJIB email', fn: unpaywall, catatan: 'butuh DOI — bukan pencari kata kunci' },
+  // Indonesia
+  { id: 'garuda', label: 'Garuda', region: 'indonesia', kind: 'html', credit: null, fn: garuda, catatan: 'artikel jurnal Indonesia' },
+  { id: 'sinta', label: 'Sinta', region: 'indonesia', kind: 'html', credit: null, fn: sinta, catatan: 'daftar JURNAL terakreditasi, bukan artikel' },
+  { id: 'ios', label: 'IOS OneSearch', region: 'indonesia', kind: 'html', credit: null, fn: ios, catatan: 'agregator repositori Indonesia' },
+];
+
+export const ID_SUMBER = SUMBER.map((s) => s.id);
+export const ID_INTERNASIONAL = SUMBER.filter((s) => s.region === 'international').map((s) => s.id);
+export const ID_INDONESIA = SUMBER.filter((s) => s.region === 'indonesia').map((s) => s.id);
+export const ID_DOI = SUMBER.filter((s) => s.input === 'doi').map((s) => s.id);
+
+/**
+ * Apakah query ini berbentuk DOI? Dipakai untuk memutuskan apakah sumber
+ * ber-input DOI (unpaywall) ikut dijalankan saat pengguna memilih "all".
+ * Tanpa ini, setiap pencarian kata kunci membayar satu permintaan yang pasti
+ * kosong — dan menampilkan baris yang tidak menjelaskan apa pun.
+ */
+export function apakahDoi(q) {
+  return /^(?:doi:\s*)?10\.\d{4,9}\/\S+$/i.test(String(q ?? '').trim());
+}
+
+export function cariSumber(id) {
+  return SUMBER.find((s) => s.id === id) ?? null;
+}
+
+/**
+ * Jalankan satu sumber. SELALU mengembalikan { id, papers, error, ms } —
+ * tidak pernah melempar — supaya satu sumber yang mati tidak membatalkan
+ * seluruh pencarian, dan kegagalannya tetap terlihat oleh pemanggil.
+ */
+export async function searchSource(id, query, opts) {
+  const s = cariSumber(id);
+  if (!s) return { id, papers: [], error: `sumber tidak dikenal: ${id}`, ms: 0 };
+  const mulai = Date.now();
+  try {
+    const papers = await s.fn(query, opts);
+    return { id, papers: Array.isArray(papers) ? papers : [], error: null, ms: Date.now() - mulai };
+  } catch (e) {
+    const pesan = e?.name === 'AbortError'
+      ? 'timeout'
+      : `${e?.message ?? 'gagal'}${e?.status ? ` (HTTP ${e.status})` : ''}${e?.body ? ` — ${e.body}` : ''}`;
+    return { id, papers: [], error: pesan, ms: Date.now() - mulai };
+  }
+}
+
+// ── Dedup ────────────────────────────────────────────────────────────────────
+
+const kunciJudul = (t) => String(t ?? '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().slice(0, 120);
+
+/**
+ * Buang duplikat: DOI lebih dulu, lalu judul yang dinormalkan.
+ * `sources` mencatat SEMUA sumber yang menemukan paper itu — supaya pengguna
+ * tahu sebuah paper muncul di beberapa basis, bukan disembunyikan.
+ */
+export function dedup(papers) {
+  const peta = new Map();
+  for (const p of papers) {
+    const kunci = p.doi ? `doi:${p.doi}` : `t:${kunciJudul(p.title)}`;
+    const ada = peta.get(kunci);
+    if (!ada) {
+      peta.set(kunci, { ...p, sources: [p.source] });
+      continue;
+    }
+    if (!ada.sources.includes(p.source)) ada.sources.push(p.source);
+    // Lengkapi medan yang kosong dari salinan lain — jangan buang informasinya.
+    for (const f of ['abstract', 'journal', 'doi', 'url', 'year']) {
+      if (!ada[f] && p[f]) ada[f] = p[f];
+    }
+    if (!ada.openAccess && p.openAccess) ada.openAccess = true;
+    if (p.authors?.length > (ada.authors?.length ?? 0)) ada.authors = p.authors;
+  }
+  return [...peta.values()];
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "dsh-paper-search",
+  "version": "0.1.0",
+  "description": "Literature search for DeepSeek Harness: thirteen international sources (Crossref, OpenAlex, DOAJ, Europe PMC, PubMed, PubMed Central, arXiv, Semantic Scholar, CORE, Zenodo, HAL, IACR ePrint, Unpaywall) and three Indonesian journal portals (Garuda, Sinta, IOS OneSearch), all native HTTP with no external CLI required, plus a status tool that reports which sources answer and which credentials are configured.",
+  "license": "MIT",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/",
+    "skills/",
+    "cordis.patch.yml",
+    "README.md",
+    "CHANGELOG.md",
+    "NOTICE.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rasyidmmz/dsh-paper-search.git"
+  },
+  "homepage": "https://github.com/rasyidmmz/dsh-paper-search#readme",
+  "bugs": {
+    "url": "https://github.com/rasyidmmz/dsh-paper-search/issues"
+  },
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "dsh",
+    "cordis",
+    "paper-search",
+    "literature-search",
+    "academic",
+    "journal",
+    "crossref",
+    "openalex",
+    "doaj",
+    "pubmed",
+    "arxiv",
+    "garuda",
+    "sinta"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  }
+}