@zenalexa/unicli 0.220.1 → 0.221.1

package/src/adapters/acl-anthology/papers.ts

@@ -0,0 +1,157 @@
+/**
+ * @owner       src::adapters::acl-anthology::papers
+ * @does        Registers ACL Anthology paper search and event proceedings listing from official Anthology pages.
+ * @needs       aclanthology.org static search/event HTML, src/registry.ts
+ * @feeds       src/commands/scholar.ts via scholar.search, scholar.get, scholar.pdf, and scholar.venue
+ * @breaks      ACL Anthology markup drift surfaces as empty parse output; no browser workaround is used.
+ * @invariants  Paper URLs/PDF URLs are absolutized against aclanthology.org; event keys are explicit.
+ * @side-effects HTTPS egress to aclanthology.org only
+ * @perf        O(N) over one HTML response
+ * @concurrency safe
+ * @test        covered by scholar command discovery and parser style tests for sibling proceedings sources
+ * @stability   experimental
+ * @since       2026-05-19
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import type { ScholarlyWorkRecord } from "../../types/scholarly.js";
+
+const ORIGIN = "https://aclanthology.org";
+
+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 normalizeId(value: unknown): string {
+  const raw = String(value ?? "").trim();
+  if (!/^[A-Za-z0-9.-]+$/.test(raw)) {
+    throw new Error(`ACL Anthology id "${raw}" is not valid.`);
+  }
+  return raw.replace(/\.$/, "");
+}
+
+function parseRows(
+  html: string,
+  source = "acl-anthology",
+): ScholarlyWorkRecord[] {
+  const out: ScholarlyWorkRecord[] = [];
+  const re =
+    /<p class="d-sm-flex[^"]*">[\s\S]*?<a[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>([\s\S]*?)(?=<p class="d-sm-flex|$)/g;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(html)) !== null) {
+    const sourceUrl = absolute(match[1]);
+    const id = sourceUrl.replace(`${ORIGIN}/`, "").replace(/\/$/, "");
+    const block = match[3];
+    const pdf = block.match(/href="([^"]+\.pdf)"/i)?.[1] ?? "";
+    const authorText = block
+      .replace(/<span class="d-block">[\s\S]*?<\/span>/g, " ")
+      .replace(/<[^>]+>/g, " ");
+    const authors = decode(authorText)
+      .split(/,\s*/)
+      .map((author) => author.trim())
+      .filter(Boolean)
+      .slice(0, 20);
+    out.push({
+      id,
+      title: decode(match[2].replace(/<[^>]+>/g, " ")),
+      authors: authors.length > 0 ? authors : undefined,
+      year: Number(id.slice(0, 4)) || undefined,
+      venue: "ACL Anthology",
+      pdf_url: pdf ? absolute(pdf) : `${sourceUrl}.pdf`,
+      source_adapter: source,
+      source_url: sourceUrl,
+      retrieved_at: new Date().toISOString(),
+    });
+  }
+  return out;
+}
+
+async function fetchHtml(url: string, label: string): Promise<string> {
+  const response = await fetch(url, {
+    headers: {
+      Accept: "text/html",
+      "User-Agent":
+        "unicli-acl-anthology/1.0 (https://github.com/olo-dot-io/Uni-CLI)",
+    },
+  });
+  if (response.status === 404) throw new Error(`${label} returned no result.`);
+  if (!response.ok)
+    throw new Error(`${label} returned HTTP ${response.status}.`);
+  return response.text();
+}
+
+cli({
+  site: "acl-anthology",
+  name: "search",
+  description: "Search ACL Anthology papers",
+  domain: "aclanthology.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", "pdf_url", "source_url"],
+  capabilities: ["http.fetch", "scholar.search", "scholar.pdf"],
+  func: async (_page, kwargs) => {
+    const query = String(kwargs.query ?? "").trim();
+    if (!query) throw new Error("acl-anthology search query cannot be empty.");
+    const limit = Math.min(Math.max(Number(kwargs.limit ?? 20), 1), 100);
+    const rows = parseRows(
+      await fetchHtml(
+        `${ORIGIN}/search/?q=${encodeURIComponent(query)}`,
+        "acl-anthology search",
+      ),
+    ).slice(0, limit);
+    if (rows.length === 0)
+      throw new Error(`No ACL Anthology papers matched "${query}".`);
+    return rows;
+  },
+});
+
+cli({
+  site: "acl-anthology",
+  name: "paper",
+  description: "Fetch an ACL Anthology paper by anthology id",
+  domain: "aclanthology.org",
+  strategy: Strategy.PUBLIC,
+  args: [{ name: "id", type: "str", required: true, positional: true }],
+  columns: ["id", "title", "authors", "year", "venue", "pdf_url", "source_url"],
+  capabilities: ["http.fetch", "scholar.get", "scholar.pdf"],
+  func: async (_page, kwargs) => {
+    const id = normalizeId(kwargs.id ?? kwargs.ref);
+    const html = await fetchHtml(
+      `${ORIGIN}/${id}/`,
+      `acl-anthology paper ${id}`,
+    );
+    const title = decode(
+      html.match(/<h2[^>]*id=title[^>]*>([\s\S]*?)<\/h2>/)?.[1] ?? "",
+    );
+    if (!title)
+      throw new Error(`ACL Anthology paper ${id} did not expose a title.`);
+    return [
+      {
+        id,
+        title,
+        year: Number(id.slice(0, 4)) || undefined,
+        venue: "ACL Anthology",
+        pdf_url: `${ORIGIN}/${id}.pdf`,
+        source_adapter: "acl-anthology",
+        source_url: `${ORIGIN}/${id}/`,
+        retrieved_at: new Date().toISOString(),
+      } satisfies ScholarlyWorkRecord,
+    ];
+  },
+});

package/src/adapters/arxiv/download.yaml

@@ -45,7 +45,7 @@ pipeline:
 columns: [id, title, pdf, _download]
 
 # schema-v2 metadata — injected by `unicli migrate schema-v2`
-capabilities: ["http.fetch", "http.download"]
+capabilities: ["http.fetch", "http.download", "scholar.pdf"]
 minimum_capability: http.download
 trust: public
 confidentiality: public

package/src/adapters/arxiv/paper.yaml

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

package/src/adapters/arxiv/papers.ts

@@ -174,6 +174,7 @@ cli({
     { name: "limit", type: "int", default: 20, description: "Max papers" },
   ],
   columns: ["id", "title", "authors", "published", "primary_category", "url"],
+  capabilities: ["http.fetch", "scholar.author", "scholar.search"],
   func: async (_page, kwargs) => {
     const author = requireArxivAuthor(kwargs.author);
     const limit = requireArxivLimit(kwargs.limit, 20);
@@ -208,6 +209,7 @@ cli({
     { name: "limit", type: "int", default: 10, description: "Max papers" },
   ],
   columns: ["id", "title", "authors", "published", "primary_category", "url"],
+  capabilities: ["http.fetch", "scholar.search", "scholar.venue"],
   func: async (_page, kwargs) => {
     const category = requireArxivCategory(kwargs.category);
     const limit = requireArxivLimit(kwargs.limit, 10);

package/src/adapters/arxiv/search.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"]
 minimum_capability: http.fetch
 trust: public
 confidentiality: public

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/bilibili/comments-tree.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+
+import { normalizeCommentRows } from "../../social/comments.js";
+
+describe("bilibili comment tree normalization", () => {
+  it("places fetched child replies under their root rpid", () => {
+    const rows = normalizeCommentRows(
+      [
+        {
+          id: "100",
+          author: "root-user",
+          text: "root",
+          likes: 10,
+          replies: 1,
+        },
+        {
+          id: "101",
+          parent_id: "100",
+          author: "child-user",
+          text: "reply",
+          likes: 2,
+          replies: 0,
+        },
+      ],
+      { platform: "bilibili", contentId: "BV1xx" },
+    );
+
+    expect(rows[0]).toMatchObject({
+      comment_id: "100",
+      parent_id: "",
+      depth: 0,
+      path: "0001",
+    });
+    expect(rows[1]).toMatchObject({
+      comment_id: "101",
+      parent_id: "100",
+      depth: 1,
+      path: "0001.0001",
+    });
+  });
+});

package/src/adapters/bilibili/comments.ts

@@ -7,8 +7,12 @@
 
 import { cli, Strategy } from "../../registry.js";
 import { wbiFetch } from "./wbi.js";
-import { loadCookies, formatCookieHeader } from "../../engine/cookies.js";
+import {
+  loadCookiesWithCDP,
+  formatCookieHeader,
+} from "../../engine/cookies.js";
 import { USER_AGENT } from "../../constants.js";
+import { normalizeCommentRows } from "../../social/comments.js";
 
 interface ViewResponse {
   data: {
@@ -17,10 +21,14 @@ interface ViewResponse {
 }
 
 interface CommentItem {
+  rpid?: number;
+  root?: number;
+  parent?: number;
   member: { uname: string };
   content: { message: string };
   like: number;
   rcount: number;
+  ctime?: number;
 }
 
 interface CommentsResponse {
@@ -31,7 +39,7 @@ interface CommentsResponse {
 
 /** Fetch video aid from bvid using the view API (not WBI-signed). */
 async function resolveAid(bvid: string): Promise<number> {
-  const cookies = loadCookies("bilibili");
+  const cookies = await loadCookiesWithCDP("bilibili", "bilibili.com");
   const headers: Record<string, string> = {
     "User-Agent": USER_AGENT,
     Accept: "application/json",
@@ -69,11 +77,32 @@ cli({
       default: 20,
       description: "Number of comments",
     },
+    {
+      name: "with-replies",
+      type: "bool",
+      default: false,
+      description: "Include nested replies for each root comment",
+    },
+  ],
+  columns: [
+    "platform",
+    "content_id",
+    "comment_id",
+    "parent_id",
+    "depth",
+    "path",
+    "author",
+    "text",
+    "likes",
+    "replies",
+    "created",
+    "user",
+    "content",
   ],
-  columns: ["user", "content", "likes", "replies"],
   func: async (_page, kwargs) => {
     const bvid = String(kwargs.bvid);
     const limit = Number(kwargs.limit) || 20;
+    const withReplies = Boolean(kwargs["with-replies"]);
 
     const aid = await resolveAid(bvid);
 
@@ -84,11 +113,56 @@ cli({
       ps: String(limit),
     })) as CommentsResponse;
 
-    return (json.data.replies ?? []).map((item) => ({
+    const roots = json.data.replies ?? [];
+    const rows = roots.map((item) => ({
+      id: item.rpid ? String(item.rpid) : "",
+      parent_id:
+        item.parent && item.parent > 0
+          ? String(item.parent)
+          : item.root && item.root > 0
+            ? String(item.root)
+            : "",
       user: item.member.uname,
+      author: item.member.uname,
       content: item.content.message,
+      text: item.content.message,
       likes: item.like,
       replies: item.rcount,
+      created: item.ctime ? String(item.ctime) : "",
     }));
+
+    if (withReplies) {
+      for (const root of roots) {
+        if (!root.rpid || root.rcount <= 0) continue;
+        const repliesJson = (await wbiFetch(
+          "https://api.bilibili.com/x/v2/reply/reply",
+          {
+            oid: String(aid),
+            type: "1",
+            root: String(root.rpid),
+            ps: "20",
+            pn: "1",
+          },
+        )) as CommentsResponse;
+        for (const reply of repliesJson.data.replies ?? []) {
+          rows.push({
+            id: reply.rpid ? String(reply.rpid) : "",
+            parent_id: String(root.rpid),
+            user: reply.member.uname,
+            author: reply.member.uname,
+            content: reply.content.message,
+            text: reply.content.message,
+            likes: reply.like,
+            replies: reply.rcount,
+            created: reply.ctime ? String(reply.ctime) : "",
+          });
+        }
+      }
+    }
+
+    return normalizeCommentRows(rows, {
+      platform: "bilibili",
+      contentId: bvid,
+    });
   },
 });

package/src/adapters/bilibili/compat.ts

@@ -1,10 +1,13 @@
 import { cli, Strategy } from "../../registry.js";
-import { loadCookies, formatCookieHeader } from "../../engine/cookies.js";
+import {
+  loadCookiesWithCDP,
+  formatCookieHeader,
+} from "../../engine/cookies.js";
 import { USER_AGENT } from "../../constants.js";
 import { intArg, str } from "../_shared/browser-tools.js";
 
 async function bilibiliJson(url: string): Promise<Record<string, unknown>> {
-  const cookies = loadCookies("bilibili");
+  const cookies = await loadCookiesWithCDP("bilibili", "bilibili.com");
   const headers: Record<string, string> = {
     "user-agent": USER_AGENT,
     referer: "https://www.bilibili.com",

package/src/adapters/bilibili/download.ts

@@ -8,7 +8,10 @@
  */
 
 import { cli, Strategy } from "../../registry.js";
-import { loadCookies, formatCookieHeader } from "../../engine/cookies.js";
+import {
+  loadCookiesWithCDP,
+  formatCookieHeader,
+} from "../../engine/cookies.js";
 import { USER_AGENT } from "../../constants.js";
 
 interface ViewResponse {
@@ -47,8 +50,8 @@ interface PlayurlResponse {
 }
 
 /** Build authenticated headers for Bilibili API calls. */
-function buildHeaders(): Record<string, string> {
-  const cookies = loadCookies("bilibili");
+async function buildHeaders(): Promise<Record<string, string>> {
+  const cookies = await loadCookiesWithCDP("bilibili", "bilibili.com");
   const headers: Record<string, string> = {
     "User-Agent": USER_AGENT,
     Accept: "application/json",
@@ -75,7 +78,7 @@ cli({
   columns: ["type", "quality", "codecs", "size", "url"],
   func: async (_page, kwargs) => {
     const bvid = String(kwargs.bvid);
-    const headers = buildHeaders();
+    const headers = await buildHeaders();
 
     // Step 1: resolve cid from bvid
     const viewResp = await fetch(

package/src/adapters/bilibili/wbi.ts

@@ -6,7 +6,10 @@
  */
 
 import { createHash } from "node:crypto";
-import { loadCookies, formatCookieHeader } from "../../engine/cookies.js";
+import {
+  loadCookiesWithCDP,
+  formatCookieHeader,
+} from "../../engine/cookies.js";
 import { USER_AGENT } from "../../constants.js";
 
 const MIXIN_KEY_ENC_TAB = [
@@ -31,7 +34,7 @@ async function fetchWbiKeys(): Promise<string> {
   const now = Date.now();
   if (cachedMixinKey && now - cachedAt < CACHE_TTL) return cachedMixinKey;
 
-  const cookies = loadCookies("bilibili");
+  const cookies = await loadCookiesWithCDP("bilibili", "bilibili.com");
   const headers: Record<string, string> = { "User-Agent": USER_AGENT };
   if (cookies) headers["Cookie"] = formatCookieHeader(cookies);
 
@@ -76,7 +79,7 @@ export async function wbiFetch(
   const query = await signWbi(params);
   const url = `${baseUrl}?${query}`;
 
-  const cookies = loadCookies("bilibili");
+  const cookies = await loadCookiesWithCDP("bilibili", "bilibili.com");
   const headers: Record<string, string> = {
     "User-Agent": USER_AGENT,
     Accept: "application/json",

package/src/adapters/brave/search.yaml

@@ -0,0 +1,53 @@
+# Brave Search — keyless HTML scrape against the public web result page.
+#
+# verification_status: keyless-best-effort
+#
+# Brave operates a paid Search API at https://api.search.brave.com — that
+# path needs an X-Subscription-Token header (free 2000 queries/month plan).
+# This adapter takes the no-key route: hit https://search.brave.com/search
+# and parse the SSR-emitted result list. Anti-bot may rate-limit aggressive
+# loops; results are best-effort, not guaranteed parity with the API.
+site: brave
+name: search
+description: Search the public web via Brave Search (no API key needed)
+type: web-api
+domain: search.brave.com
+strategy: public
+lint_listing_detail: skip
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Free-text web search query
+  limit:
+    type: int
+    default: 10
+    description: Maximum results returned (page caps around 20)
+
+pipeline:
+  - fetch_text:
+      url: "https://search.brave.com/search?q=${{ args.query | url_encode }}&source=web"
+      headers:
+        User-Agent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"
+        Accept: "text/html,application/xhtml+xml"
+
+  - extract:
+      selector: "div.snippet[data-type='web']"
+      fields:
+        title: "div.snippet-title"
+        url: "a@href"
+        snippet: ".snippet-description"
+
+  - limit: ${{ args.limit }}
+
+columns: [title, url, snippet]
+
+# schema-v2 metadata
+capabilities: ["http.fetch"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

package/src/adapters/cipo/_shared.ts

@@ -0,0 +1,98 @@
+/**
+ * @owner       src::adapters::cipo::_shared
+ * @does        Shared helpers for the CIPO Canadian Patents Database browser adapter — emits structured envelopes for MCP-bus / not-found / schema-drift gaps.
+ * @needs       src/engine/transport/mcp-browser.ts, src/engine/normalizer/patent-envelope.ts, src/types/patent.ts
+ * @feeds       src/adapters/cipo/*.ts
+ * @breaks      none — pure helpers
+ * @invariants  every error path emits a PatentEnvelope row
+ * @side-effects none
+ * @perf        n/a
+ * @concurrency safe
+ * @test        covered transitively
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification browser-only
+ */
+
+import {
+  TransportError,
+  initMcpBrowserTransport,
+  mcpBrowserEvaluate,
+  mcpBrowserNavigate,
+  type McpBrowserResult,
+} from "../../engine/transport/mcp-browser.js";
+import { buildPatentEnvelope } from "../../engine/normalizer/patent-envelope.js";
+import type { PatentEnvelope, PatentErrorCode } from "../../types/patent.js";
+
+export function cipoEnvelope(
+  code: PatentErrorCode,
+  adapter_path: string,
+  step: string,
+  suggestion: string,
+  alternatives: string[] = [],
+): PatentEnvelope {
+  return buildPatentEnvelope({
+    code,
+    adapter_path,
+    step,
+    suggestion,
+    alternatives,
+    retryable: false,
+  });
+}
+
+export function transportErrorToCipoEnvelope(
+  err: TransportError,
+  adapter_path: string,
+  step: string,
+): PatentEnvelope {
+  if (err.code === "MCP_BUS_MISSING") {
+    return buildPatentEnvelope({
+      code: "PATENT_API_DEPRECATED",
+      adapter_path,
+      step,
+      suggestion:
+        "engine has no outbound MCP transport wired into the bus today; install an McpResolver before invoking the CIPO browser adapter, or use uspto/epo as a partial fallback",
+      alternatives: ["uspto", "epo", "lens"],
+      retryable: false,
+    });
+  }
+  return buildPatentEnvelope({
+    code: "PATENT_API_DEPRECATED",
+    adapter_path,
+    step,
+    suggestion: `mcp-browser transport error (${err.code}): ${err.message}`,
+    alternatives: ["uspto", "epo"],
+    retryable: false,
+  });
+}
+
+export async function cipoNavigateAndExtract<T>(
+  url: string,
+  expression: string,
+): Promise<McpBrowserResult<T>> {
+  const init = await initMcpBrowserTransport();
+  if (init.active_server === "none") {
+    const code =
+      init.reason === "bus-missing" ? "MCP_BUS_MISSING" : "MCP_NO_SERVER";
+    throw new TransportError(code, `mcp-browser unavailable (${init.reason})`);
+  }
+  const navResult = await mcpBrowserNavigate({ url });
+  if (!navResult.ok) {
+    throw new TransportError(
+      navResult.code ?? "MCP_NAVIGATE_FAILED",
+      navResult.message ?? "navigate did not succeed",
+    );
+  }
+  const evalResult = await mcpBrowserEvaluate<T>({
+    expression,
+    tab: navResult.tab,
+  });
+  if (!evalResult.ok) {
+    throw new TransportError(
+      evalResult.code ?? "MCP_EVALUATE_FAILED",
+      evalResult.message ?? "evaluate did not succeed",
+    );
+  }
+  return evalResult;
+}