@zenalexa/unicli 0.221.0 → 0.221.1

package/src/adapters/crossref/works.ts

@@ -0,0 +1,209 @@
+/**
+ * @owner       src::adapters::crossref::works
+ * @does        Registers Crossref REST work search and DOI lookup commands for publisher metadata.
+ * @needs       api.crossref.org REST API, optional CROSSREF_MAILTO, src/registry.ts
+ * @feeds       src/commands/scholar.ts via scholar.search and scholar.get
+ * @breaks      Crossref response-shape drift or rate limiting surfaces as explicit adapter errors.
+ * @invariants  DOI lookup accepts only DOI-shaped references; output maps to ScholarlyWorkRecord.
+ * @side-effects HTTPS egress to api.crossref.org only
+ * @perf        O(limit) JSON mapping
+ * @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.crossref.org";
+
+interface CrossrefPerson {
+  given?: unknown;
+  family?: unknown;
+  name?: unknown;
+}
+
+interface CrossrefItem {
+  DOI?: unknown;
+  title?: unknown[];
+  subtitle?: unknown[];
+  author?: CrossrefPerson[];
+  "container-title"?: unknown[];
+  issued?: { "date-parts"?: unknown[][] };
+  published?: { "date-parts"?: unknown[][] };
+  "is-referenced-by-count"?: unknown;
+  reference?: unknown[];
+  URL?: unknown;
+  type?: unknown;
+  abstract?: unknown;
+}
+
+function str(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function arrFirst(value: unknown): string {
+  return Array.isArray(value) ? str(value[0]) : str(value);
+}
+
+function num(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value)
+    ? value
+    : undefined;
+}
+
+function dateParts(item: CrossrefItem): unknown[] {
+  return (
+    item.issued?.["date-parts"]?.[0] ??
+    item.published?.["date-parts"]?.[0] ??
+    []
+  );
+}
+
+function year(item: CrossrefItem): number | undefined {
+  const first = dateParts(item)[0];
+  return typeof first === "number" && Number.isFinite(first)
+    ? first
+    : undefined;
+}
+
+function date(item: CrossrefItem): string | undefined {
+  const parts = dateParts(item).filter(
+    (part): part is number => typeof part === "number",
+  );
+  if (parts.length === 0) return undefined;
+  return [
+    String(parts[0]).padStart(4, "0"),
+    String(parts[1] ?? 1).padStart(2, "0"),
+    String(parts[2] ?? 1).padStart(2, "0"),
+  ].join("-");
+}
+
+function authors(value: CrossrefPerson[] | undefined): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const out = value
+    .map(
+      (person) =>
+        str(person.name) ||
+        [person.given, person.family].map(str).filter(Boolean).join(" "),
+    )
+    .filter(Boolean);
+  return out.length > 0 ? out : undefined;
+}
+
+function bareDoi(value: unknown): string {
+  return str(value)
+    .replace(/^doi:/i, "")
+    .replace(/^https?:\/\/(?:dx\.)?doi\.org\//i, "");
+}
+
+export function requireCrossrefDoi(value: unknown): string {
+  const doi = bareDoi(value);
+  if (!/^10\.\S+\/\S+/.test(doi)) {
+    throw new Error(`crossref DOI "${String(value ?? "")}" is not recognised.`);
+  }
+  return doi;
+}
+
+function maybeMailto(params: URLSearchParams): void {
+  const mailto = process.env.CROSSREF_MAILTO?.trim();
+  if (mailto) params.set("mailto", mailto);
+}
+
+async function fetchCrossref(path: string, label: string): Promise<unknown> {
+  const response = await fetch(`${API}${path}`, {
+    headers: {
+      Accept: "application/json",
+      "User-Agent":
+        "unicli-crossref/1.0 (https://github.com/olo-dot-io/Uni-CLI)",
+    },
+  });
+  if (response.status === 404) throw new Error(`${label} returned no result.`);
+  if (response.status === 429) throw new Error(`${label} returned HTTP 429.`);
+  if (!response.ok)
+    throw new Error(`${label} returned HTTP ${response.status}.`);
+  return response.json();
+}
+
+export function mapCrossrefItem(
+  item: CrossrefItem,
+  source: string,
+): ScholarlyWorkRecord {
+  const doi = requireCrossrefDoi(item.DOI);
+  return {
+    id: doi,
+    title: arrFirst(item.title),
+    authors: authors(item.author),
+    year: year(item),
+    date: date(item),
+    venue: arrFirst(item["container-title"]) || undefined,
+    type: str(item.type) || undefined,
+    abstract: str(item.abstract).replace(/<[^>]+>/g, " ") || undefined,
+    doi,
+    cited_by_count: num(item["is-referenced-by-count"]),
+    references_count: Array.isArray(item.reference)
+      ? item.reference.length
+      : undefined,
+    source_adapter: source,
+    source_url: str(item.URL) || `https://doi.org/${doi}`,
+    retrieved_at: new Date().toISOString(),
+  };
+}
+
+cli({
+  site: "crossref",
+  name: "search",
+  description:
+    "Search Crossref Works by title, author, DOI, or bibliographic text",
+  domain: "api.crossref.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", "source_url"],
+  capabilities: ["http.fetch", "scholar.search"],
+  func: async (_page, kwargs) => {
+    const query = String(kwargs.query ?? "").trim();
+    if (!query) throw new Error("crossref search query cannot be empty.");
+    const limit = Math.min(Math.max(Number(kwargs.limit ?? 20), 1), 100);
+    const params = new URLSearchParams({ query, rows: String(limit) });
+    maybeMailto(params);
+    const body = (await fetchCrossref(
+      `/works?${params.toString()}`,
+      "crossref search",
+    )) as {
+      message?: { items?: CrossrefItem[] };
+    };
+    const rows = (body.message?.items ?? []).map((item) =>
+      mapCrossrefItem(item, "crossref"),
+    );
+    if (rows.length === 0)
+      throw new Error(`No Crossref works matched "${query}".`);
+    return rows;
+  },
+});
+
+cli({
+  site: "crossref",
+  name: "work",
+  description: "Fetch one Crossref Work by DOI",
+  domain: "api.crossref.org",
+  strategy: Strategy.PUBLIC,
+  args: [{ name: "doi", type: "str", required: true, positional: true }],
+  columns: ["id", "title", "authors", "year", "venue", "doi", "source_url"],
+  capabilities: ["http.fetch", "scholar.get"],
+  func: async (_page, kwargs) => {
+    const doi = requireCrossrefDoi(kwargs.doi ?? kwargs.id ?? kwargs.ref);
+    const params = new URLSearchParams();
+    maybeMailto(params);
+    const suffix = params.size > 0 ? `?${params.toString()}` : "";
+    const body = (await fetchCrossref(
+      `/works/${encodeURIComponent(doi)}${suffix}`,
+      `crossref work ${doi}`,
+    )) as { message?: CrossrefItem };
+    if (!body.message) throw new Error(`Crossref returned no work for ${doi}.`);
+    return [mapCrossrefItem(body.message, "crossref")];
+  },
+});

package/src/adapters/cvf/papers.ts

@@ -0,0 +1,136 @@
+/**
+ * @owner       src::adapters::cvf::papers
+ * @does        Registers CVF OpenAccess conference paper search for CVPR/ICCV/ECCV-style proceedings pages.
+ * @needs       openaccess.thecvf.com static proceedings HTML, src/registry.ts
+ * @feeds       src/commands/scholar.ts via scholar.search, scholar.pdf, and scholar.venue
+ * @breaks      CVF markup drift surfaces as empty/parse errors rather than non-CVF fallbacks.
+ * @invariants  Venue/year map to explicit CVF event pages; PDF URLs are absolutized against openaccess.thecvf.com.
+ * @side-effects HTTPS egress to openaccess.thecvf.com only
+ * @perf        O(N) over one proceedings HTML page
+ * @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 ORIGIN = "https://openaccess.thecvf.com";
+
+function decode(value: string): string {
+  return value
+    .replace(/&/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function absolute(path: string): string {
+  return /^https?:\/\//i.test(path)
+    ? path
+    : `${ORIGIN}${path.startsWith("/") ? "" : "/"}${path}`;
+}
+
+function eventId(venue: unknown, year: unknown): string {
+  const v = String(venue ?? "CVPR")
+    .trim()
+    .toUpperCase();
+  const y = String(year ?? "").trim();
+  if (!/^(CVPR|ICCV|ECCV|WACV)$/.test(v))
+    throw new Error(`unsupported CVF venue: ${v}`);
+  if (!/^\d{4}$/.test(y)) throw new Error(`cvf year "${y}" is not valid.`);
+  return `${v}${y}`;
+}
+
+export function parseCvfRows(
+  html: string,
+  event = "CVPR2024",
+): ScholarlyWorkRecord[] {
+  const out: ScholarlyWorkRecord[] = [];
+  const re =
+    /<dt class="ptitle">[\s\S]*?<a href="([^"]+)">([\s\S]*?)<\/a><\/dt>([\s\S]*?)(?=<dt class="ptitle">|$)/g;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(html)) !== null) {
+    const sourceUrl = absolute(match[1]);
+    const title = decode(match[2].replace(/<[^>]+>/g, " "));
+    const block = match[3];
+    const pdf = block.match(/<a href="([^"]+\.pdf)">pdf<\/a>/i)?.[1] ?? "";
+    const authorText = block
+      .replace(/\[[\s\S]*?\]/g, " ")
+      .replace(/<form[\s\S]*?<\/form>/g, " ")
+      .replace(/<[^>]+>/g, " ");
+    const authors = decode(authorText)
+      .split(",")
+      .map((author) => author.trim())
+      .filter(Boolean);
+    out.push({
+      id:
+        sourceUrl
+          .split("/")
+          .pop()
+          ?.replace(/\.html$/, "") ?? title,
+      title,
+      authors: authors.length > 0 ? authors : undefined,
+      year: Number(event.slice(-4)),
+      venue: event.replace(/\d{4}$/, ""),
+      pdf_url: pdf ? absolute(pdf) : undefined,
+      source_adapter: "cvf",
+      source_url: sourceUrl,
+      retrieved_at: new Date().toISOString(),
+    });
+  }
+  return out;
+}
+
+cli({
+  site: "cvf",
+  name: "search",
+  description: "Search CVF OpenAccess proceedings (CVPR/ICCV/ECCV/WACV)",
+  domain: "openaccess.thecvf.com",
+  strategy: Strategy.PUBLIC,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "venue", type: "str", default: "CVPR" },
+    { name: "year", type: "str", default: "2024" },
+    { 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("cvf search query cannot be empty.");
+    const event = eventId(kwargs.venue, kwargs.year);
+    const response = await fetch(`${ORIGIN}/${event}?day=all`, {
+      headers: {
+        Accept: "*/*",
+        "User-Agent": "unicli-cvf/1.0 (https://github.com/olo-dot-io/Uni-CLI)",
+      },
+    });
+    if (response.status === 404)
+      throw new Error(`CVF ${event} returned no proceedings page.`);
+    if (!response.ok)
+      throw new Error(`CVF ${event} returned HTTP ${response.status}.`);
+    const limit = Math.min(Math.max(Number(kwargs.limit ?? 20), 1), 200);
+    const rows = parseCvfRows(await response.text(), event)
+      .filter((row) =>
+        `${row.title} ${row.authors?.join(" ") ?? ""}`
+          .toLowerCase()
+          .includes(query),
+      )
+      .slice(0, limit);
+    if (rows.length === 0)
+      throw new Error(`No CVF ${event} papers matched "${query}".`);
+    return rows;
+  },
+});

package/src/adapters/dblp/publications.ts

@@ -332,6 +332,7 @@ cli({
     "doi",
     "url",
   ],
+  capabilities: ["http.fetch", "scholar.search"],
   func: async (_page, kwargs) => {
     const query = requireDblpQuery(kwargs.query);
     const limit = requireDblpLimit(kwargs.limit, 20, 100);
@@ -375,6 +376,7 @@ cli({
     "open_access_url",
     "dblp_url",
   ],
+  capabilities: ["http.fetch", "scholar.get", "scholar.pdf"],
   func: async (_page, kwargs) => {
     const key = requireRecordKey(kwargs.key);
     const xml = await fetchDblpXml(
@@ -406,6 +408,7 @@ cli({
     { name: "limit", type: "int", default: 20, description: "Max venues" },
   ],
   columns: ["rank", "acronym", "venue", "type", "url"],
+  capabilities: ["http.fetch", "scholar.venue"],
   func: async (_page, kwargs) => {
     const query = requireDblpQuery(kwargs.query);
     const limit = requireDblpLimit(kwargs.limit, 20, 100);
@@ -455,6 +458,7 @@ cli({
     "pid",
     "url",
   ],
+  capabilities: ["http.fetch", "scholar.author", "scholar.search"],
   func: async (_page, kwargs) => {
     const limit = requireDblpLimit(kwargs.limit, 20, 200);
     let pid = kwargs.pid ? requirePid(kwargs.pid) : "";

package/src/adapters/google-scholar/cite.ts

@@ -27,6 +27,7 @@ cli({
     { name: "index", type: "int", default: 1 },
   ],
   columns: ["title", "format", "citation"],
+  capabilities: ["mcp-browser.navigate", "mcp-browser.evaluate", "scholar.get"],
   func: async (page, kwargs) => {
     const p = page as IPage;
     const query = str(kwargs.query).trim();

package/src/adapters/google-scholar/profile.ts

@@ -18,6 +18,11 @@ cli({
     { name: "limit", type: "int", default: 10 },
   ],
   columns: ["rank", "kind", "title", "authors", "year", "cited", "url"],
+  capabilities: [
+    "mcp-browser.navigate",
+    "mcp-browser.evaluate",
+    "scholar.author",
+  ],
   func: async (page, kwargs) => {
     const p = page as IPage;
     const author = str(kwargs.author).trim();

package/src/adapters/google-scholar/search.ts

@@ -14,6 +14,11 @@ cli({
     { name: "limit", type: "int", default: 10 },
   ],
   columns: ["rank", "title", "authors", "source", "year", "cited", "url"],
+  capabilities: [
+    "mcp-browser.navigate",
+    "mcp-browser.evaluate",
+    "scholar.search",
+  ],
   func: async (page, kwargs) => {
     const p = page as IPage;
     const limit = intArg(kwargs.limit, 10, 20);

package/src/adapters/hf/paper.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+import { getAdapter } from "../../registry.js";
 import { hfEndpoint, mapHfPaperRow, requireHfPaperId } from "./paper.js";
 
 describe("hf agent-facing paper command", () => {
@@ -45,4 +46,13 @@ describe("hf agent-facing paper command", () => {
   it("rejects empty HF paper payloads", () => {
     expect(() => mapHfPaperRow({})).toThrow("no paper data");
   });
+
+  it("advertises scholarly capabilities for meta-command discovery", () => {
+    expect(getAdapter("hf")?.commands.paper?.capabilities).toEqual([
+      "http.fetch",
+      "scholar.get",
+      "scholar.pdf",
+      "scholar.code",
+    ]);
+  });
 });

package/src/adapters/hf/paper.ts

@@ -131,6 +131,7 @@ cli({
     "aiSummary",
     "url",
   ],
+  capabilities: ["http.fetch", "scholar.get", "scholar.pdf", "scholar.code"],
   func: async (_page, kwargs) => {
     const id = requireHfPaperId(kwargs.id);
     return [mapHfPaperRow(await fetchHfPaper(id), hfEndpoint())];

package/src/adapters/hf/top.yaml

@@ -32,7 +32,7 @@ pipeline:
 columns: [rank, id, title, upvotes, authors]
 
 # schema-v2 metadata — injected by `unicli migrate schema-v2`
-capabilities: ["http.fetch"]
+capabilities: ["http.fetch", "scholar.search", "scholar.code"]
 minimum_capability: http.fetch
 trust: public
 confidentiality: public

package/src/adapters/huggingface-papers/daily.yaml

@@ -21,7 +21,7 @@ pipeline:
 columns: [title, authors, upvotes, url]
 
 # schema-v2 metadata — injected by `unicli migrate schema-v2`
-capabilities: ["http.fetch"]
+capabilities: ["http.fetch", "scholar.search", "scholar.code"]
 minimum_capability: http.fetch
 trust: public
 confidentiality: public

package/src/adapters/huggingface-papers/search.yaml

@@ -34,7 +34,7 @@ pipeline:
 columns: [title, authors, upvotes, published, url]
 
 # schema-v2 metadata — injected by `unicli migrate schema-v2`
-capabilities: ["http.fetch"]
+capabilities: ["http.fetch", "scholar.search", "scholar.code"]
 minimum_capability: http.fetch
 trust: public
 confidentiality: public

package/src/adapters/neurips/proceedings.ts

@@ -0,0 +1,126 @@
+/**
+ * @owner       src::adapters::neurips::proceedings
+ * @does        Registers NeurIPS proceedings search over the official yearly paper list.
+ * @needs       proceedings.neurips.cc static HTML, src/registry.ts
+ * @feeds       src/commands/scholar.ts via scholar.search, scholar.pdf, and scholar.venue
+ * @breaks      NeurIPS markup drift surfaces as empty parse output; no unrelated source fallback is used.
+ * @invariants  Year is explicit; paper URLs are absolutized against proceedings.neurips.cc.
+ * @side-effects HTTPS egress to proceedings.neurips.cc only
+ * @perf        O(N) over one proceedings HTML page
+ * @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 ORIGIN = "https://proceedings.neurips.cc";
+
+function decode(value: string): string {
+  return value
+    .replace(/&/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function absolute(path: string): string {
+  return /^https?:\/\//i.test(path)
+    ? path
+    : `${ORIGIN}${path.startsWith("/") ? "" : "/"}${path}`;
+}
+
+function requireYear(value: unknown): string {
+  const year = String(value ?? "").trim();
+  if (!/^\d{4}$/.test(year))
+    throw new Error(`neurips year "${year}" is not valid.`);
+  return year;
+}
+
+export function parseNeuripsRows(
+  html: string,
+  year = "2024",
+): ScholarlyWorkRecord[] {
+  const out: ScholarlyWorkRecord[] = [];
+  const re =
+    /<div class="paper-content">[\s\S]*?<a title="paper title" href="([^"]+)">([\s\S]*?)<\/a>[\s\S]*?<span class="paper-authors">([\s\S]*?)<\/span>/g;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(html)) !== null) {
+    const sourceUrl = absolute(match[1]);
+    out.push({
+      id:
+        sourceUrl
+          .split("/")
+          .pop()
+          ?.replace(/\.html$/, "") ?? decode(match[2]),
+      title: decode(match[2].replace(/<[^>]+>/g, " ")),
+      authors: decode(match[3])
+        .split(",")
+        .map((author) => author.trim())
+        .filter(Boolean),
+      year: Number(year),
+      venue: "NeurIPS",
+      pdf_url: sourceUrl
+        .replace("-Abstract-", "-Paper-")
+        .replace(/\.html$/, ".pdf"),
+      source_adapter: "neurips",
+      source_url: sourceUrl,
+      retrieved_at: new Date().toISOString(),
+    });
+  }
+  return out;
+}
+
+cli({
+  site: "neurips",
+  name: "search",
+  description: "Search NeurIPS proceedings by year",
+  domain: "proceedings.neurips.cc",
+  strategy: Strategy.PUBLIC,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "year", type: "str", default: "2024" },
+    { 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("neurips search query cannot be empty.");
+    const year = requireYear(kwargs.year);
+    const response = await fetch(`${ORIGIN}/paper_files/paper/${year}`, {
+      headers: {
+        Accept: "text/html",
+        "User-Agent":
+          "unicli-neurips/1.0 (https://github.com/olo-dot-io/Uni-CLI)",
+      },
+    });
+    if (response.status === 404)
+      throw new Error(`NeurIPS ${year} returned no proceedings page.`);
+    if (!response.ok)
+      throw new Error(`NeurIPS ${year} returned HTTP ${response.status}.`);
+    const limit = Math.min(Math.max(Number(kwargs.limit ?? 20), 1), 200);
+    const rows = parseNeuripsRows(await response.text(), year)
+      .filter((row) =>
+        `${row.title} ${row.authors?.join(" ") ?? ""}`
+          .toLowerCase()
+          .includes(query),
+      )
+      .slice(0, limit);
+    if (rows.length === 0)
+      throw new Error(`No NeurIPS ${year} papers matched "${query}".`);
+    return rows;
+  },
+});

package/src/adapters/openalex/works.ts

@@ -164,6 +164,14 @@ function authors(work: OpenAlexWork): string {
     : "";
 }
 
+function authorList(work: OpenAlexWork): string[] {
+  return Array.isArray(work.authorships)
+    ? work.authorships
+        .map((item) => stringField(item.author?.display_name).trim())
+        .filter(Boolean)
+    : [];
+}
+
 function venue(work: OpenAlexWork): string {
   return stringField(work.primary_location?.source?.display_name).trim();
 }
@@ -181,10 +189,17 @@ export function mapOpenAlexSearchRows(
       year: numberField(work.publication_year),
       citations: numberField(work.cited_by_count),
       firstAuthor: firstAuthor(work),
+      authors: authorList(work),
       venue: venue(work),
       openAccess: Boolean(work.open_access?.is_oa),
+      is_open_access: Boolean(work.open_access?.is_oa),
       type: stringField(work.type).trim(),
       doi: bareDoi(work.doi),
+      pdf_url: stringField(work.open_access?.oa_url).trim(),
+      openalex_id: id,
+      source_adapter: "openalex",
+      source_url: id ? `https://openalex.org/${id}` : "",
+      retrieved_at: new Date().toISOString(),
       url: id ? `https://openalex.org/${id}` : "",
     };
   });
@@ -203,15 +218,26 @@ export function mapOpenAlexWorkRow(
     date: stringField(work.publication_date).trim(),
     language: stringField(work.language).trim(),
     authors: authors(work),
+    author_list: authorList(work),
     venue: venue(work),
     citations: numberField(work.cited_by_count),
+    cited_by_count: numberField(work.cited_by_count),
     openAccess: Boolean(work.open_access?.is_oa),
+    is_open_access: Boolean(work.open_access?.is_oa),
     openAccessUrl: stringField(work.open_access?.oa_url).trim(),
+    pdf_url: stringField(work.open_access?.oa_url).trim(),
     referencedCount: Array.isArray(work.referenced_works)
       ? work.referenced_works.length
       : null,
+    references_count: Array.isArray(work.referenced_works)
+      ? work.referenced_works.length
+      : null,
     doi: bareDoi(work.doi),
     abstract: reconstructOpenAlexAbstract(work.abstract_inverted_index),
+    openalex_id: id,
+    source_adapter: "openalex",
+    source_url: `https://openalex.org/${id}`,
+    retrieved_at: new Date().toISOString(),
     url: `https://openalex.org/${id}`,
   };
 }
@@ -259,6 +285,7 @@ cli({
     "doi",
     "url",
   ],
+  capabilities: ["http.fetch", "scholar.search"],
   func: async (_page, kwargs) => {
     const query = requireOpenAlexString(kwargs.query, "query");
     const limit = requireOpenAlexLimit(kwargs.limit);
@@ -308,6 +335,12 @@ cli({
     "abstract",
     "url",
   ],
+  capabilities: [
+    "http.fetch",
+    "scholar.get",
+    "scholar.pdf",
+    "scholar.references",
+  ],
   func: async (_page, kwargs) => {
     const ref = requireOpenAlexWorkRef(kwargs.id);
     const work = (await fetchOpenAlex(