@zenalexa/unicli 0.221.0 → 0.222.0

package/src/adapters/arxiv/trending.yaml

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

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

@@ -14,6 +14,11 @@ cli({
     { name: "limit", type: "int", default: 10 },
   ],
   columns: ["title", "authors", "source", "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, 50);

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/figma/export-selected.yaml

@@ -1,21 +1,21 @@
-# CUA+AX demo — export the currently-selected Figma frame.
+# Visual+AX demo — export the currently-selected Figma frame.
 #
 # Composes three transports:
 #   1. desktop-ax    → launch & focus the desktop Figma app
-#   2. cua           → VLM confirms the export dialog is visible
+#   2. visual           → VLM confirms the export dialog is visible
 #   3. desktop-ax    → click through the File > Export menu path
 #
-# Quarantined because the Figma desktop app and a VLM backend
-# (ANTHROPIC_API_KEY | TRYCUA_API_KEY | …) are both required.
+# Quarantined because the Figma desktop app and a visual backend are both
+# required.
 site: figma
 name: export-selected
-description: Export the currently-selected Figma frame via CUA + macOS AX
+description: Export the currently-selected Figma frame via Visual + macOS AX
 type: browser
 strategy: ui
 domain: figma.com
 browser: false
 quarantine: true
-quarantineReason: Requires macOS + Figma desktop app + a CUA backend (ANTHROPIC_API_KEY etc.) (quarantined 2026-04-15)
+quarantineReason: Requires macOS + Figma desktop app + a visual backend (quarantined 2026-04-15)
 args:
   format:
     type: str
@@ -30,12 +30,12 @@ pipeline:
   - ax_focus:
       app: Figma
 
-  - cua_wait:
+  - visual_wait:
       ms: 500
 
-  - cua_snapshot: {}
+  - visual_snapshot: {}
 
-  - cua_ask:
+  - visual_ask:
       question: Is a frame currently selected on the Figma canvas?
 
   - ax_menu_select:
@@ -44,10 +44,10 @@ pipeline:
         - File
         - Export ${{ args.format }}
 
-  - cua_wait:
+  - visual_wait:
       ms: 800
 
-  - cua_assert:
+  - visual_assert:
       predicate: The Figma export dialog is visible with a Save button
 
 columns: [backend, ok]
@@ -55,15 +55,15 @@ columns: [backend, ok]
 # schema-v2 metadata — injected by `unicli migrate schema-v2`
 capabilities:
   [
-    "cua.ask",
-    "cua.assert",
-    "cua.snapshot",
-    "cua.wait",
+    "visual.ask",
+    "visual.assert",
+    "visual.snapshot",
+    "visual.wait",
     "desktop-ax.focus",
     "desktop-ax.launch_app",
     "desktop-ax.menu_select",
   ]
-minimum_capability: cua.snapshot
+minimum_capability: visual.snapshot
 trust: user
 confidentiality: public
 schema_version: v2

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