@zenalexa/unicli 0.221.0 → 0.221.1

package/src/adapters/openreview/papers.ts

@@ -303,6 +303,7 @@ cli({
     { name: "limit", type: "int", default: 25, description: "Max results" },
   ],
   columns: ["rank", "id", "title", "authors", "venue", "pdate", "url"],
+  capabilities: ["http.fetch", "scholar.search", "scholar.review"],
   func: async (_page, kwargs) => {
     const query = String(kwargs.query ?? "").trim();
     if (!query) throw new Error("openreview search query cannot be empty.");
@@ -363,6 +364,7 @@ cli({
     "pdf",
     "url",
   ],
+  capabilities: ["http.fetch", "scholar.get", "scholar.pdf", "scholar.review"],
   func: async (_page, kwargs) => {
     const id = requireForumId(kwargs.id);
     const notes = notesFromEnvelope(
@@ -409,6 +411,7 @@ cli({
     { name: "limit", type: "int", default: 50, description: "Max submissions" },
   ],
   columns: ["rank", "id", "title", "authors", "venue", "pdate", "url"],
+  capabilities: ["http.fetch", "scholar.author", "scholar.search"],
   func: async (_page, kwargs) => {
     const profile = requireProfileId(kwargs.profile);
     const limit = requireOpenReviewLimit(kwargs.limit, 50, 1000);
@@ -473,6 +476,7 @@ cli({
     "pdf",
     "url",
   ],
+  capabilities: ["http.fetch", "scholar.venue", "scholar.search"],
   func: async (_page, kwargs) => {
     const venue = String(kwargs.venue ?? "").trim();
     if (!venue) throw new Error("openreview venue cannot be empty.");
@@ -531,6 +535,7 @@ cli({
     },
   ],
   columns: ["type", "author", "rating", "confidence", "text"],
+  capabilities: ["http.fetch", "scholar.review"],
   func: async (_page, kwargs) => {
     const forum = requireForumId(kwargs.forum, "forum");
     const maxLength = coerceOpenReviewInt(

package/src/adapters/pmlr/proceedings.ts

@@ -0,0 +1,167 @@
+/**
+ * @owner       src::adapters::pmlr::proceedings
+ * @does        Registers Proceedings of Machine Learning Research volume search using official citeproc.yaml metadata.
+ * @needs       proceedings.mlr.press citeproc.yaml files, js-yaml, src/registry.ts
+ * @feeds       src/commands/scholar.ts via scholar.search, scholar.get, scholar.pdf, and scholar.venue
+ * @breaks      Missing volume metadata or citeproc drift surfaces as explicit adapter errors.
+ * @invariants  Volume is explicit; rows are filtered locally from official YAML metadata, not scraped from rendered cards.
+ * @side-effects HTTPS egress to proceedings.mlr.press only
+ * @perf        O(N) over one proceedings volume
+ * @concurrency safe
+ * @test        tests/unit/adapters/scholar-sources.test.ts
+ * @stability   experimental
+ * @since       2026-05-19
+ */
+
+import yaml from "js-yaml";
+import { cli, Strategy } from "../../registry.js";
+import type { ScholarlyWorkRecord } from "../../types/scholarly.js";
+
+interface PmlrEntry {
+  title?: unknown;
+  abstract?: unknown;
+  URL?: unknown;
+  PDF?: unknown;
+  "container-title"?: unknown;
+  author?: Array<{ given?: unknown; family?: unknown }>;
+  id?: unknown;
+  issued?: { "date-parts"?: unknown[] };
+  volume?: unknown;
+}
+
+function str(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function authors(value: PmlrEntry["author"]): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const out = value
+    .map((person) =>
+      [person.given, person.family].map(str).filter(Boolean).join(" "),
+    )
+    .filter(Boolean);
+  return out.length > 0 ? out : undefined;
+}
+
+function issuedYear(entry: PmlrEntry): number | undefined {
+  const first = entry.issued?.["date-parts"]?.[0];
+  return typeof first === "number" && Number.isFinite(first)
+    ? first
+    : undefined;
+}
+
+export function parsePmlrCiteproc(text: string): PmlrEntry[] {
+  const parsed = yaml.load(text);
+  return Array.isArray(parsed) ? (parsed as PmlrEntry[]) : [];
+}
+
+export function mapPmlrEntry(
+  entry: PmlrEntry,
+  source: string,
+): ScholarlyWorkRecord {
+  const id = str(entry.id);
+  if (!id) throw new Error("PMLR entry did not include id.");
+  return {
+    id,
+    title: str(entry.title),
+    abstract: str(entry.abstract) || undefined,
+    authors: authors(entry.author),
+    year: issuedYear(entry),
+    venue: str(entry["container-title"]) || undefined,
+    type: entry.volume ? `pmlr:${String(entry.volume)}` : "pmlr",
+    pdf_url: str(entry.PDF) || undefined,
+    source_adapter: source,
+    source_url: str(entry.URL) || undefined,
+    retrieved_at: new Date().toISOString(),
+  };
+}
+
+function requireVolume(value: unknown): string {
+  const raw = String(value ?? "")
+    .trim()
+    .replace(/^v/i, "");
+  if (!/^\d+$/.test(raw))
+    throw new Error(`pmlr volume "${String(value)}" is not valid.`);
+  return raw;
+}
+
+async function fetchVolume(volume: string): Promise<PmlrEntry[]> {
+  const response = await fetch(
+    `https://proceedings.mlr.press/v${volume}/assets/bib/citeproc.yaml`,
+    {
+      headers: {
+        Accept: "application/x-yaml,text/yaml,text/plain",
+        "User-Agent": "unicli-pmlr/1.0 (https://github.com/olo-dot-io/Uni-CLI)",
+      },
+    },
+  );
+  if (response.status === 404)
+    throw new Error(`PMLR volume v${volume} returned no metadata.`);
+  if (!response.ok)
+    throw new Error(`PMLR volume v${volume} returned HTTP ${response.status}.`);
+  return parsePmlrCiteproc(await response.text());
+}
+
+cli({
+  site: "pmlr",
+  name: "search",
+  description: "Search a PMLR proceedings volume (e.g. v235 for ICML 2024)",
+  domain: "proceedings.mlr.press",
+  strategy: Strategy.PUBLIC,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "volume", type: "str", default: "235" },
+    { name: "limit", type: "int", default: 20 },
+  ],
+  columns: ["id", "title", "authors", "year", "venue", "pdf_url", "source_url"],
+  capabilities: [
+    "http.fetch",
+    "scholar.search",
+    "scholar.venue",
+    "scholar.pdf",
+  ],
+  func: async (_page, kwargs) => {
+    const query = String(kwargs.query ?? "")
+      .trim()
+      .toLowerCase();
+    if (!query) throw new Error("pmlr search query cannot be empty.");
+    const volume = requireVolume(kwargs.volume);
+    const limit = Math.min(Math.max(Number(kwargs.limit ?? 20), 1), 200);
+    const rows = (await fetchVolume(volume))
+      .map((entry) => mapPmlrEntry(entry, "pmlr"))
+      .filter((row) =>
+        `${row.title} ${row.abstract ?? ""} ${row.authors?.join(" ") ?? ""}`
+          .toLowerCase()
+          .includes(query),
+      )
+      .slice(0, limit);
+    if (rows.length === 0)
+      throw new Error(`No PMLR v${volume} papers matched "${query}".`);
+    return rows;
+  },
+});
+
+cli({
+  site: "pmlr",
+  name: "paper",
+  description: "Fetch a PMLR paper by id inside a proceedings volume",
+  domain: "proceedings.mlr.press",
+  strategy: Strategy.PUBLIC,
+  args: [
+    { name: "id", type: "str", required: true, positional: true },
+    { name: "volume", type: "str", default: "235" },
+  ],
+  columns: ["id", "title", "authors", "year", "venue", "pdf_url", "source_url"],
+  capabilities: ["http.fetch", "scholar.get", "scholar.pdf"],
+  func: async (_page, kwargs) => {
+    const id = String(kwargs.id ?? kwargs.ref ?? "").trim();
+    if (!id) throw new Error("pmlr paper id is required.");
+    const volume = requireVolume(kwargs.volume);
+    const row = (await fetchVolume(volume))
+      .map((entry) => mapPmlrEntry(entry, "pmlr"))
+      .find((entry) => entry.id === id);
+    if (!row)
+      throw new Error(`No PMLR v${volume} paper found with id "${id}".`);
+    return [row];
+  },
+});

package/src/adapters/pubmed/articles.ts

@@ -304,6 +304,7 @@ cli({
     { name: "limit", type: "int", default: 20, description: "Max results" },
   ],
   columns: SUMMARY_COLUMNS,
+  capabilities: ["http.fetch", "scholar.search"],
   func: async (_page, kwargs) => {
     const query = requirePubMedText(kwargs.query, "query");
     const limit = requirePubMedLimit(kwargs.limit);
@@ -345,6 +346,7 @@ cli({
     },
   ],
   columns: ["field", "value"],
+  capabilities: ["http.fetch", "scholar.get"],
   func: async (_page, kwargs) => {
     const pmid = requirePmid(kwargs.pmid);
     const xml = String(
@@ -371,6 +373,7 @@ cli({
     { name: "limit", type: "int", default: 20, description: "Max results" },
   ],
   columns: SUMMARY_COLUMNS,
+  capabilities: ["http.fetch", "scholar.author", "scholar.search"],
   func: async (_page, kwargs) => {
     const name = requirePubMedText(kwargs.name, "author");
     const limit = requirePubMedLimit(kwargs.limit);
@@ -414,6 +417,7 @@ cli({
     { name: "limit", type: "int", default: 20, description: "Max results" },
   ],
   columns: SUMMARY_COLUMNS,
+  capabilities: ["http.fetch", "scholar.citations", "scholar.references"],
   func: async (_page, kwargs) => {
     const pmid = requirePmid(kwargs.pmid);
     const direction = requireChoice(
@@ -459,6 +463,7 @@ cli({
     { name: "limit", type: "int", default: 20, description: "Max results" },
   ],
   columns: RELATED_COLUMNS,
+  capabilities: ["http.fetch", "scholar.search"],
   func: async (_page, kwargs) => {
     const pmid = requirePmid(kwargs.pmid);
     const limit = requirePubMedLimit(kwargs.limit);

package/src/adapters/semantic-scholar/papers.ts

@@ -0,0 +1,268 @@
+/**
+ * @owner       src::adapters::semantic-scholar::papers
+ * @does        Registers Semantic Scholar Graph API paper search, detail, citations, references, and PDF discovery commands.
+ * @needs       api.semanticscholar.org Graph v1, optional SEMANTIC_SCHOLAR_API_KEY, src/registry.ts
+ * @feeds       src/commands/scholar.ts via scholar.* capability tags
+ * @breaks      Graph API rate limits or response-shape drift surface as explicit adapter errors; no cached fallback is used.
+ * @invariants  Paper references are normalized to Semantic Scholar's accepted DOI:/ARXIV:/paperId formats; output maps to ScholarlyWorkRecord.
+ * @side-effects HTTPS egress to api.semanticscholar.org only
+ * @perf        O(limit) JSON mapping per command
+ * @concurrency safe
+ * @test        tests/unit/adapters/scholar-sources.test.ts
+ * @stability   experimental
+ * @since       2026-05-19
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import type { ScholarlyWorkRecord } from "../../types/scholarly.js";
+
+const API = "https://api.semanticscholar.org/graph/v1";
+const FIELDS = [
+  "paperId",
+  "title",
+  "abstract",
+  "year",
+  "authors",
+  "citationCount",
+  "referenceCount",
+  "venue",
+  "publicationVenue",
+  "url",
+  "openAccessPdf",
+  "externalIds",
+].join(",");
+
+interface S2Paper {
+  paperId?: unknown;
+  title?: unknown;
+  abstract?: unknown;
+  year?: unknown;
+  authors?: Array<{ name?: unknown }>;
+  citationCount?: unknown;
+  referenceCount?: unknown;
+  venue?: unknown;
+  url?: unknown;
+  openAccessPdf?: { url?: unknown };
+  externalIds?: Record<string, unknown>;
+}
+
+function str(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function num(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value)
+    ? value
+    : undefined;
+}
+
+function bareDoi(value: unknown): string {
+  return str(value)
+    .replace(/^doi:/i, "")
+    .replace(/^https?:\/\/(?:dx\.)?doi\.org\//i, "");
+}
+
+function bareArxiv(value: unknown): string {
+  return str(value)
+    .replace(/^arxiv:/i, "")
+    .replace(/^https?:\/\/arxiv\.org\/(?:abs|pdf)\//i, "")
+    .replace(/\.pdf$/i, "")
+    .replace(/v\d+$/i, "");
+}
+
+export function requireSemanticScholarPaperRef(value: unknown): string {
+  const raw = String(value ?? "").trim();
+  if (!raw) throw new Error("semantic-scholar paper reference is required.");
+  const doi = bareDoi(raw);
+  if (/^10\.\S+\/\S+/.test(doi)) return `DOI:${doi}`;
+  if (
+    /^(?:arxiv:|https?:\/\/arxiv\.org\/(?:abs|pdf)\/|\d{4}\.\d{4,5})/i.test(raw)
+  ) {
+    return `ARXIV:${bareArxiv(raw)}`;
+  }
+  if (/^[a-f0-9]{40}$/i.test(raw)) return raw;
+  throw new Error(
+    `semantic-scholar paper reference "${raw}" is not recognised.`,
+  );
+}
+
+function headers(): Record<string, string> {
+  const out: Record<string, string> = {
+    Accept: "application/json",
+    "User-Agent":
+      "unicli-semantic-scholar/1.0 (https://github.com/olo-dot-io/Uni-CLI)",
+  };
+  const key = process.env.SEMANTIC_SCHOLAR_API_KEY?.trim();
+  if (key) out["x-api-key"] = key;
+  return out;
+}
+
+async function fetchS2(path: string, label: string): Promise<unknown> {
+  const response = await fetch(`${API}${path}`, { headers: headers() });
+  if (response.status === 404) throw new Error(`${label} returned no result.`);
+  if (response.status === 429) {
+    throw new Error(
+      `${label} returned HTTP 429; set SEMANTIC_SCHOLAR_API_KEY or retry later.`,
+    );
+  }
+  if (!response.ok)
+    throw new Error(`${label} returned HTTP ${response.status}.`);
+  const json = (await response.json()) as {
+    error?: unknown;
+    message?: unknown;
+  };
+  if (json.error || json.message) {
+    throw new Error(
+      `${label} returned API error: ${String(json.error ?? json.message)}.`,
+    );
+  }
+  return json;
+}
+
+export function mapSemanticScholarPaper(
+  paper: S2Paper,
+  source: string,
+): ScholarlyWorkRecord {
+  const id = str(paper.paperId);
+  if (!id)
+    throw new Error("Semantic Scholar returned a paper without paperId.");
+  const doi = bareDoi(paper.externalIds?.DOI);
+  const arxiv = bareArxiv(paper.externalIds?.ArXiv);
+  return {
+    id,
+    title: str(paper.title),
+    abstract: str(paper.abstract) || undefined,
+    authors: Array.isArray(paper.authors)
+      ? paper.authors.map((author) => str(author.name)).filter(Boolean)
+      : undefined,
+    year: num(paper.year),
+    venue: str(paper.venue) || undefined,
+    doi: doi || undefined,
+    arxiv_id: arxiv || undefined,
+    semantic_scholar_id: id,
+    cited_by_count: num(paper.citationCount),
+    references_count: num(paper.referenceCount),
+    pdf_url: str(paper.openAccessPdf?.url) || undefined,
+    source_adapter: source,
+    source_url: str(paper.url) || `https://www.semanticscholar.org/paper/${id}`,
+    retrieved_at: new Date().toISOString(),
+  };
+}
+
+function rows(
+  papers: unknown,
+  source = "semantic-scholar",
+): ScholarlyWorkRecord[] {
+  const list = Array.isArray(papers) ? papers : [];
+  return list.map((paper) => mapSemanticScholarPaper(paper as S2Paper, source));
+}
+
+cli({
+  site: "semantic-scholar",
+  name: "search",
+  description: "Search Semantic Scholar papers",
+  domain: "api.semanticscholar.org",
+  strategy: Strategy.PUBLIC,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 20 },
+  ],
+  columns: [
+    "id",
+    "title",
+    "authors",
+    "year",
+    "venue",
+    "doi",
+    "pdf_url",
+    "source_url",
+  ],
+  capabilities: ["http.fetch", "scholar.search"],
+  func: async (_page, kwargs) => {
+    const query = String(kwargs.query ?? "").trim();
+    if (!query)
+      throw new Error("semantic-scholar search query cannot be empty.");
+    const limit = Math.min(Math.max(Number(kwargs.limit ?? 20), 1), 100);
+    const body = (await fetchS2(
+      `/paper/search?query=${encodeURIComponent(query)}&limit=${limit}&fields=${encodeURIComponent(FIELDS)}`,
+      "semantic-scholar search",
+    )) as { data?: S2Paper[] };
+    const out = rows(body.data);
+    if (out.length === 0)
+      throw new Error(`No Semantic Scholar papers matched "${query}".`);
+    return out;
+  },
+});
+
+cli({
+  site: "semantic-scholar",
+  name: "paper",
+  description: "Fetch one Semantic Scholar paper by paperId, DOI, or arXiv id",
+  domain: "api.semanticscholar.org",
+  strategy: Strategy.PUBLIC,
+  args: [{ name: "id", type: "str", required: true, positional: true }],
+  columns: [
+    "id",
+    "title",
+    "authors",
+    "year",
+    "venue",
+    "doi",
+    "pdf_url",
+    "source_url",
+  ],
+  capabilities: ["http.fetch", "scholar.get", "scholar.pdf"],
+  func: async (_page, kwargs) => {
+    const ref = requireSemanticScholarPaperRef(
+      kwargs.id ?? kwargs.ref ?? kwargs.doi ?? kwargs.arxiv_id,
+    );
+    const paper = (await fetchS2(
+      `/paper/${encodeURIComponent(ref)}?fields=${encodeURIComponent(FIELDS)}`,
+      `semantic-scholar paper ${ref}`,
+    )) as S2Paper;
+    return [mapSemanticScholarPaper(paper, "semantic-scholar")];
+  },
+});
+
+for (const [name, path, cap] of [
+  ["citations", "citations", "scholar.citations"],
+  ["references", "references", "scholar.references"],
+] as const) {
+  cli({
+    site: "semantic-scholar",
+    name,
+    description: `List Semantic Scholar paper ${name}`,
+    domain: "api.semanticscholar.org",
+    strategy: Strategy.PUBLIC,
+    args: [
+      { name: "id", type: "str", required: true, positional: true },
+      { name: "limit", type: "int", default: 20 },
+    ],
+    columns: [
+      "id",
+      "title",
+      "authors",
+      "year",
+      "venue",
+      "doi",
+      "pdf_url",
+      "source_url",
+    ],
+    capabilities: ["http.fetch", cap],
+    func: async (_page, kwargs) => {
+      const ref = requireSemanticScholarPaperRef(kwargs.id ?? kwargs.ref);
+      const limit = Math.min(Math.max(Number(kwargs.limit ?? 20), 1), 100);
+      const body = (await fetchS2(
+        `/paper/${encodeURIComponent(ref)}/${path}?limit=${limit}&fields=${encodeURIComponent(FIELDS)}`,
+        `semantic-scholar ${name} ${ref}`,
+      )) as { data?: Array<{ citingPaper?: S2Paper; citedPaper?: S2Paper }> };
+      const papers = (body.data ?? []).map((item) =>
+        name === "citations" ? item.citingPaper : item.citedPaper,
+      );
+      const out = rows(papers);
+      if (out.length === 0)
+        throw new Error(`No Semantic Scholar ${name} found for ${ref}.`);
+      return out;
+    },
+  });
+}

package/src/adapters/unpaywall/works.ts

@@ -0,0 +1,138 @@
+/**
+ * @owner       src::adapters::unpaywall::works
+ * @does        Registers Unpaywall DOI open-access lookup for PDF availability.
+ * @needs       api.unpaywall.org v2, UNPAYWALL_EMAIL or --email, src/registry.ts
+ * @feeds       src/commands/scholar.ts via scholar.pdf and scholar.get
+ * @breaks      Missing email is an explicit invalid-input error; Unpaywall drift surfaces as adapter error, never as a fabricated PDF.
+ * @invariants  Only DOI-shaped references are accepted; best_oa_location is preferred for PDF and landing URLs.
+ * @side-effects HTTPS egress to api.unpaywall.org only
+ * @perf        O(1) per DOI
+ * @concurrency safe
+ * @test        tests/unit/adapters/scholar-sources.test.ts
+ * @stability   experimental
+ * @since       2026-05-19
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import type { ScholarlyWorkRecord } from "../../types/scholarly.js";
+
+const API = "https://api.unpaywall.org/v2";
+
+interface OaLocation {
+  url_for_pdf?: unknown;
+  url_for_landing_page?: unknown;
+  host_type?: unknown;
+  version?: unknown;
+  license?: unknown;
+}
+
+interface UnpaywallWork {
+  doi?: unknown;
+  title?: unknown;
+  is_oa?: unknown;
+  oa_status?: unknown;
+  best_oa_location?: OaLocation | null;
+}
+
+function str(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function bareDoi(value: unknown): string {
+  return str(value)
+    .replace(/^doi:/i, "")
+    .replace(/^https?:\/\/(?:dx\.)?doi\.org\//i, "");
+}
+
+export function requireUnpaywallDoi(value: unknown): string {
+  const doi = bareDoi(value);
+  if (!/^10\.\S+\/\S+/.test(doi)) {
+    throw new Error(
+      `unpaywall DOI "${String(value ?? "")}" is not recognised.`,
+    );
+  }
+  return doi;
+}
+
+function requireEmail(value: unknown): string {
+  const email = str(value) || process.env.UNPAYWALL_EMAIL?.trim() || "";
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+    throw new Error("unpaywall lookup requires --email or UNPAYWALL_EMAIL.");
+  }
+  return email;
+}
+
+export function mapUnpaywallWork(
+  work: UnpaywallWork,
+  source: string,
+): ScholarlyWorkRecord {
+  const doi = requireUnpaywallDoi(work.doi);
+  const best = work.best_oa_location ?? {};
+  return {
+    id: doi,
+    title: str(work.title),
+    doi,
+    is_open_access: work.is_oa === true,
+    oa_status: str(work.oa_status) || undefined,
+    pdf_url: str(best.url_for_pdf) || undefined,
+    landing_url: str(best.url_for_landing_page) || `https://doi.org/${doi}`,
+    type:
+      [str(best.host_type), str(best.version), str(best.license)]
+        .filter(Boolean)
+        .join(":") || undefined,
+    source_adapter: source,
+    source_url: str(best.url_for_landing_page) || `https://doi.org/${doi}`,
+    retrieved_at: new Date().toISOString(),
+  };
+}
+
+async function fetchUnpaywall(
+  doi: string,
+  email: string,
+): Promise<UnpaywallWork> {
+  const response = await fetch(
+    `${API}/${encodeURIComponent(doi)}?email=${encodeURIComponent(email)}`,
+    {
+      headers: {
+        Accept: "application/json",
+        "User-Agent":
+          "unicli-unpaywall/1.0 (https://github.com/olo-dot-io/Uni-CLI)",
+      },
+    },
+  );
+  if (response.status === 404)
+    throw new Error(`Unpaywall returned no result for ${doi}.`);
+  if (response.status === 422)
+    throw new Error("Unpaywall rejected the email parameter.");
+  if (response.status === 429) throw new Error("Unpaywall returned HTTP 429.");
+  if (!response.ok)
+    throw new Error(`Unpaywall returned HTTP ${response.status}.`);
+  return response.json() as Promise<UnpaywallWork>;
+}
+
+cli({
+  site: "unpaywall",
+  name: "oa",
+  description: "Find open-access PDF availability for a DOI via Unpaywall",
+  domain: "api.unpaywall.org",
+  strategy: Strategy.PUBLIC,
+  args: [
+    { name: "doi", type: "str", required: true, positional: true },
+    { name: "email", type: "str", description: "Unpaywall requester email" },
+  ],
+  columns: [
+    "id",
+    "title",
+    "doi",
+    "is_open_access",
+    "oa_status",
+    "pdf_url",
+    "source_url",
+  ],
+  capabilities: ["http.fetch", "scholar.get", "scholar.pdf"],
+  func: async (_page, kwargs) => {
+    const doi = requireUnpaywallDoi(kwargs.doi ?? kwargs.id ?? kwargs.ref);
+    const email = requireEmail(kwargs.email);
+    return [mapUnpaywallWork(await fetchUnpaywall(doi, email), "unpaywall")];
+  },
+});

package/src/adapters/zotero/search.yaml

@@ -38,7 +38,7 @@ pipeline:
 columns: [key, title, type, date, creators]
 
 # schema-v2 metadata — injected by `unicli migrate schema-v2`
-capabilities: ["http.fetch"]
+capabilities: ["http.fetch", "scholar.search"]
 minimum_capability: http.fetch
 trust: public
 confidentiality: public