@zenalexa/unicli 0.220.1 → 0.221.1

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(

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/patsnap/get.yaml

@@ -0,0 +1,65 @@
+# PatSnap Eureka — single-record fetch.
+#
+# verification_status: blocked-by-subscription
+#
+# Maps to PatSnap's /patent/biblio/{publication_number} endpoint. The same
+# OAuth2 token resolution pattern as `patsnap/search.yaml`.
+site: patsnap
+name: get
+description: Retrieve one PatSnap patent record by publication number
+domain: connect.zhihuiya.com
+type: web-api
+strategy: header
+
+args:
+  publication_number:
+    type: str
+    required: true
+    positional: true
+
+pipeline:
+  - oauth2-token:
+      token_url: https://connect.zhihuiya.com/oauth/token
+      client_id_env: PATSNAP_CLIENT_ID
+      client_secret_env: PATSNAP_CLIENT_SECRET
+      site: patsnap
+      destination: auth.bearer
+
+  - fetch:
+      url: "https://connect.zhihuiya.com/patent/biblio"
+      params:
+        patent_number: "${{ args.publication_number }}"
+      headers:
+        Authorization: "Bearer ${{ auth.bearer }}"
+
+  - select: data
+
+  - map:
+      publication_number: "${{ item.pn }}"
+      title: "${{ item.title }}"
+      abstract: "${{ item.abstract }}"
+      kind_code: "${{ item.kind_code || item.kindcode || '' }}"
+      filing_date: "${{ item.apdt || '' }}"
+      publication_date: "${{ item.pbdt || '' }}"
+      grant_date: "${{ item.grant_date || item.granted || '' }}"
+      priority_date: "${{ item.priority_date || item.prdate || '' }}"
+      application_number: "${{ item.application_number || item.an || '' }}"
+      family_id: "${{ item.simple_family_id || '' }}"
+      legal_status: "${{ item.legal_status || '' }}"
+      inventors: "${{ JSON.stringify((function(){ var i=item.inventor || item.inventors; if(!i) return []; if(typeof i === 'string') return i.split(/\\s*[\\|;,]\\s*/).filter(s => s).map(name => ({ name: name })); return Array.isArray(i) ? i.map(n => ({ name: typeof n === 'string' ? n : (n.name || ''), country: n.country || undefined })) : []; })()) }}"
+      assignees: "${{ JSON.stringify((function(){ var a=item.current_assignee || item.assignee || item.assignees; if(!a) return []; if(typeof a === 'string') return a.split(/\\s*[\\|;,]\\s*/).filter(s => s).map(name => ({ name: name })); return Array.isArray(a) ? a.map(n => ({ name: typeof n === 'string' ? n : (n.name || ''), country: n.country || undefined })) : []; })()) }}"
+      classifications: "${{ JSON.stringify((function(){ var out=[]; var ipc=item.ipc; if(ipc){ var arr = Array.isArray(ipc) ? ipc : String(ipc).split(/[\\|;,]/); for (var i=0;i<arr.length;i++){ var c = arr[i]; var code = typeof c === 'string' ? c.trim() : (c.code || ''); if(code) out.push({ scheme: 'ipc', code: code }); } } var cpc=item.cpc; if(cpc){ var arr2 = Array.isArray(cpc) ? cpc : String(cpc).split(/[\\|;,]/); for (var j=0;j<arr2.length;j++){ var c2 = arr2[j]; var code2 = typeof c2 === 'string' ? c2.trim() : (c2.code || ''); if(code2) out.push({ scheme: 'cpc', code: code2 }); } } return out; })()) }}"
+      cited_by_count: "${{ item.cited_by !== undefined ? item.cited_by : (item.citation_count !== undefined ? item.citation_count : '') }}"
+      cites_count: "${{ item.cites !== undefined ? item.cites : '' }}"
+      source_adapter: patsnap
+      source_url: "${{ 'https://analytics.zhihuiya.com/patent/' + (item.pn || '') }}"
+      retrieved_at: "${{ now }}"
+
+columns: [publication_number, title, legal_status, source_adapter]
+
+capabilities: ["http.fetch", "patent.get"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

package/src/adapters/patsnap/search.yaml

@@ -0,0 +1,77 @@
+# PatSnap Eureka — OAuth2 client_credentials search.
+#
+# verification_status: blocked-by-subscription
+#
+# PatSnap is a commercial patent intelligence platform. API access requires a
+# Connect / Eureka subscription with two static credentials (CLIENT_ID /
+# CLIENT_SECRET) the buyer pastes into env vars. The `oauth2-token` step
+# resolves the bearer once and caches it; downstream fetch reuses it.
+site: patsnap
+name: search
+description: PatSnap Eureka patent search via OAuth2 client_credentials
+domain: connect.zhihuiya.com
+type: web-api
+strategy: header
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+  limit:
+    type: int
+    default: 20
+
+pipeline:
+  - oauth2-token:
+      token_url: https://connect.zhihuiya.com/oauth/token
+      client_id_env: PATSNAP_CLIENT_ID
+      client_secret_env: PATSNAP_CLIENT_SECRET
+      site: patsnap
+      destination: auth.bearer
+
+  - fetch:
+      url: https://connect.zhihuiya.com/search/patent/query-search-patent/v2
+      method: POST
+      headers:
+        Authorization: "Bearer ${{ auth.bearer }}"
+        Content-Type: application/json
+      body:
+        text: "${{ args.query }}"
+        offset: 0
+        limit: "${{ args.limit }}"
+
+  - select: data.results
+
+  # PatSnap Eureka response carries inventors / assignees / classifications
+  # under documented field names.
+  - map:
+      publication_number: "${{ item.pn || item.pbd_number }}"
+      title: "${{ item.title }}"
+      abstract: "${{ item.abstract }}"
+      kind_code: "${{ item.kind_code || item.kindcode || '' }}"
+      filing_date: "${{ item.apdt || '' }}"
+      publication_date: "${{ item.pbdt || '' }}"
+      grant_date: "${{ item.grant_date || item.granted || '' }}"
+      priority_date: "${{ item.priority_date || item.prdate || '' }}"
+      application_number: "${{ item.application_number || item.an || '' }}"
+      family_id: "${{ item.simple_family_id || '' }}"
+      inventors: "${{ JSON.stringify((function(){ var i=item.inventor || item.inventors; if(!i) return []; if(typeof i === 'string') return i.split(/\\s*[\\|;,]\\s*/).filter(s => s).map(name => ({ name: name })); return Array.isArray(i) ? i.map(n => ({ name: typeof n === 'string' ? n : (n.name || ''), country: n.country || undefined })) : []; })()) }}"
+      assignees: "${{ JSON.stringify((function(){ var a=item.current_assignee || item.assignee || item.assignees; if(!a) return []; if(typeof a === 'string') return a.split(/\\s*[\\|;,]\\s*/).filter(s => s).map(name => ({ name: name })); return Array.isArray(a) ? a.map(n => ({ name: typeof n === 'string' ? n : (n.name || ''), country: n.country || undefined })) : []; })()) }}"
+      classifications: "${{ JSON.stringify((function(){ var out=[]; var ipc=item.ipc; if(ipc){ var arr = Array.isArray(ipc) ? ipc : String(ipc).split(/[\\|;,]/); for (var i=0;i<arr.length;i++){ var c = arr[i]; var code = typeof c === 'string' ? c.trim() : (c.code || ''); if(code) out.push({ scheme: 'ipc', code: code }); } } var cpc=item.cpc; if(cpc){ var arr2 = Array.isArray(cpc) ? cpc : String(cpc).split(/[\\|;,]/); for (var j=0;j<arr2.length;j++){ var c2 = arr2[j]; var code2 = typeof c2 === 'string' ? c2.trim() : (c2.code || ''); if(code2) out.push({ scheme: 'cpc', code: code2 }); } } return out; })()) }}"
+      cited_by_count: "${{ item.cited_by !== undefined ? item.cited_by : (item.citation_count !== undefined ? item.citation_count : '') }}"
+      cites_count: "${{ item.cites !== undefined ? item.cites : '' }}"
+      source_adapter: patsnap
+      source_url: "${{ 'https://analytics.zhihuiya.com/patent/' + (item.pn || item.pbd_number || '') }}"
+      retrieved_at: "${{ now }}"
+
+  - limit: ${{ args.limit }}
+
+columns: [publication_number, title, publication_date, source_adapter]
+
+capabilities: ["http.fetch", "patent.search"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

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/pqai/prior-art.yaml

@@ -0,0 +1,59 @@
+# Project PQAI — semantic prior-art retrieval.
+#
+# verification_status: blocked-by-key
+#
+# PQAI publishes a permanent free tier for non-commercial use, but rate limits
+# beyond ~100 queries / day require their USD 20 / month plan. The token is a
+# single string passed as a `token=` query param (the only auth scheme PQAI
+# offers today). Set $PQAI_API_TOKEN.
+site: pqai
+name: prior-art
+description: Semantic prior-art retrieval via PQAI's embedding-based ranker
+domain: api.projectpq.ai
+type: web-api
+strategy: public
+
+args:
+  abstract:
+    type: str
+    required: true
+    description: Candidate abstract or claim text
+  limit:
+    type: int
+    default: 20
+
+pipeline:
+  - fetch:
+      url: https://api.projectpq.ai/search/102
+      params:
+        q: "${{ args.abstract }}"
+        n: "${{ args.limit }}"
+        type: patent
+        token: "${{ env.PQAI_API_TOKEN || '' }}"
+
+  - select: results
+
+  # PQAI ships per-result `score` (semantic embedding cosine, ∈ [0, 1]).
+  # Forward as relevance_score so the meta-command's RRF stage can fuse it.
+  - map:
+      publication_number: "${{ item.id }}"
+      title: "${{ item.title }}"
+      abstract: "${{ item.abstract }}"
+      publication_date: "${{ item.publication_date || '' }}"
+      filing_date: "${{ item.filing_date || '' }}"
+      kind_code: "${{ item.kind_code || '' }}"
+      relevance_score: "${{ item.score !== undefined ? item.score : '' }}"
+      source_adapter: pqai
+      source_url: "https://search.projectpq.ai/patent/${{ item.id }}"
+      retrieved_at: "${{ now }}"
+
+  - limit: ${{ args.limit }}
+
+columns: [publication_number, title, abstract]
+
+capabilities: ["http.fetch", "patent.prior-art"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

package/src/adapters/pqai/search.yaml

@@ -0,0 +1,60 @@
+# Project PQAI — free-text keyword search.
+#
+# verification_status: blocked-by-key
+#
+# PQAI ships a `/search/102` endpoint that accepts both natural-language and
+# Boolean queries. This adapter exposes it as the standard patent.search
+# capability; the prior-art-specific tuning lives in pqai/prior-art.yaml.
+site: pqai
+name: search
+description: Keyword + semantic patent search through PQAI's hybrid index
+domain: api.projectpq.ai
+type: web-api
+strategy: public
+lint_listing_detail: skip
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+  limit:
+    type: int
+    default: 20
+
+pipeline:
+  - fetch:
+      url: https://api.projectpq.ai/search/102
+      params:
+        q: "${{ args.query }}"
+        n: "${{ args.limit }}"
+        type: patent
+        token: "${{ env.PQAI_API_TOKEN || '' }}"
+
+  - select: results
+
+  # PQAI returns `score` (∈ [0, 1] semantic relevance) alongside the patent
+  # record. Surface it as relevance_score so the downstream RRF stage can
+  # consult the per-engine ranking.
+  - map:
+      publication_number: "${{ item.id }}"
+      title: "${{ item.title }}"
+      abstract: "${{ item.abstract }}"
+      publication_date: "${{ item.publication_date || '' }}"
+      filing_date: "${{ item.filing_date || '' }}"
+      kind_code: "${{ item.kind_code || '' }}"
+      relevance_score: "${{ item.score !== undefined ? item.score : '' }}"
+      source_adapter: pqai
+      source_url: "https://search.projectpq.ai/patent/${{ item.id }}"
+      retrieved_at: "${{ now }}"
+
+  - limit: ${{ args.limit }}
+
+columns: [publication_number, title, publication_date]
+
+capabilities: ["http.fetch", "patent.search"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2