@zenalexa/unicli 0.220.0 → 0.221.0

package/src/adapters/cnipa/get.ts

@@ -0,0 +1,199 @@
+/**
+ * @owner       src::adapters::cnipa::get
+ * @does        Browser-driven retrieval of a single CNIPA patent document by publication number; loads the detail page through the mcp-browser transport and extracts the bibliographic fields into a PatentRecord.
+ * @needs       src/engine/transport/mcp-browser.ts, src/engine/normalizer/patent-envelope.ts, src/adapters/cnipa/_shared.ts, src/registry.ts
+ * @feeds       src/commands/patent.ts (capability tag patent.get)
+ * @breaks      emits PATENT_INVALID_NUMBER when input is empty or fails canonicalization; emits PATENT_NOT_FOUND when the detail page returns no fields; PATENT_BROWSER_CAPTCHA when the page is captcha-gated; PATENT_API_DEPRECATED with MCP_BUS_MISSING context when no outbound MCP transport is registered
+ * @invariants  output is a single PatentRecord row when the upstream answers; never falls back to a stub record
+ * @side-effects controls the user's Chrome via MCP
+ * @perf        single navigate + one evaluate
+ * @concurrency safe
+ * @test        tests/unit/adapters/cnipa/search.test.ts (transport-error path) — get-specific tests deferred to integration
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification browser-only
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { TransportError } from "../../engine/transport/mcp-browser.js";
+import { assemblePatentRecord } from "../../engine/normalizer/patent-envelope.js";
+import {
+  cnipaEnvelope,
+  looksLikeCaptcha,
+  navigateAndExtract,
+  transportErrorToEnvelope,
+} from "./_shared.js";
+
+const ADAPTER_PATH = "src/adapters/cnipa/get.ts";
+const CNIPA_DETAIL_URL =
+  "https://pss-system.cponline.cnipa.gov.cn/conventionalDetail";
+
+interface CnipaDetail {
+  publication_number?: string;
+  application_number?: string;
+  title?: string;
+  abstract?: string;
+  applicant?: string;
+  inventor?: string;
+  publication_date?: string;
+  filing_date?: string;
+  grant_date?: string;
+  legal_status?: string;
+  source_url?: string;
+  html_marker?: string;
+}
+
+const DETAIL_EXTRACTOR = `(() => {
+  const text = (sel) => {
+    const node = document.querySelector(sel);
+    return node ? (node.textContent || '').trim() : '';
+  };
+  return {
+    publication_number: text('[data-field="pubNo"], .publication-number'),
+    application_number: text('[data-field="appNo"], .application-number'),
+    title: text('[data-field="title"], h1.title, .invention-title'),
+    abstract: text('[data-field="abstract"], .abstract'),
+    applicant: text('[data-field="applicant"], .applicant'),
+    inventor: text('[data-field="inventor"], .inventor'),
+    publication_date: text('[data-field="pubDate"], .publication-date'),
+    filing_date: text('[data-field="appDate"], .filing-date'),
+    grant_date: text('[data-field="grantDate"], .grant-date'),
+    legal_status: text('[data-field="legalStatus"], .legal-status'),
+    source_url: location.href,
+    html_marker: document.body && document.body.innerText
+      ? document.body.innerText.slice(0, 200)
+      : '',
+  };
+})()`;
+
+export async function runCnipaGet(kwargs: {
+  publication_number: string;
+}): Promise<unknown[]> {
+  const pubNo = String(kwargs.publication_number ?? "").trim();
+  if (pubNo.length === 0) {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_INVALID_NUMBER",
+          ADAPTER_PATH,
+          "validate",
+          "cnipa get requires a non-empty publication_number",
+        ),
+      },
+    ];
+  }
+  const url = `${CNIPA_DETAIL_URL}?pubNo=${encodeURIComponent(pubNo)}`;
+  let detail: CnipaDetail;
+  try {
+    const result = await navigateAndExtract<CnipaDetail>(url, DETAIL_EXTRACTOR);
+    if (!result.data) {
+      return [
+        {
+          envelope: cnipaEnvelope(
+            "PATENT_SCHEMA_DRIFT",
+            ADAPTER_PATH,
+            "evaluate",
+            "mcp-browser evaluate returned no data; check selector schema in src/adapters/cnipa/get.ts",
+          ),
+        },
+      ];
+    }
+    detail = result.data;
+  } catch (err) {
+    if (err instanceof TransportError) {
+      return [
+        {
+          envelope: transportErrorToEnvelope(err, ADAPTER_PATH, "navigate"),
+        },
+      ];
+    }
+    throw err;
+  }
+
+  // Captcha heuristic: detail page returned without any of the expected
+  // bibliographic fields → almost certainly captcha-gated.
+  const fieldCount = [
+    detail.publication_number,
+    detail.title,
+    detail.application_number,
+    detail.publication_date,
+  ].filter(Boolean).length;
+  if (looksLikeCaptcha(fieldCount, detail.html_marker)) {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_BROWSER_CAPTCHA",
+          ADAPTER_PATH,
+          "evaluate",
+          "CNIPA detail page returned no bibliographic fields; solve the 验证码 in the open browser tab and re-run",
+          ["espacenet"],
+        ),
+      },
+    ];
+  }
+
+  const canonicalPubNo = detail.publication_number || pubNo;
+  try {
+    return [
+      assemblePatentRecord({
+        publication_number: canonicalPubNo,
+        application_number: detail.application_number || undefined,
+        title: detail.title || undefined,
+        abstract: detail.abstract || undefined,
+        assignees: detail.applicant
+          ? [{ name: detail.applicant, country: "CN" }]
+          : undefined,
+        inventors: detail.inventor
+          ? [{ name: detail.inventor, country: "CN" }]
+          : undefined,
+        publication_date: detail.publication_date || undefined,
+        filing_date: detail.filing_date || undefined,
+        grant_date: detail.grant_date || undefined,
+        legal_status: detail.legal_status || undefined,
+        source_adapter: "cnipa",
+        source_url: detail.source_url || url,
+      } as Parameters<typeof assemblePatentRecord>[0]),
+    ];
+  } catch {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_NOT_FOUND",
+          ADAPTER_PATH,
+          "normalize",
+          `cnipa detail page did not yield a valid publication_number for "${pubNo}"`,
+          ["espacenet"],
+        ),
+      },
+    ];
+  }
+}
+
+cli({
+  site: "cnipa",
+  name: "get",
+  description: "Retrieve a single CNIPA patent document by publication number",
+  domain: "pss-system.cponline.cnipa.gov.cn",
+  strategy: Strategy.PUBLIC,
+  adapter_path: ADAPTER_PATH,
+  args: [
+    {
+      name: "publication_number",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "ST.16 publication number (e.g. CN114123456A)",
+    },
+  ],
+  columns: [
+    "publication_number",
+    "title",
+    "publication_date",
+    "legal_status",
+    "source_url",
+  ],
+  capabilities: ["mcp-browser.navigate", "mcp-browser.evaluate", "patent.get"],
+  minimum_capability: "mcp-browser.evaluate",
+  func: async (_page, kwargs) =>
+    runCnipaGet(kwargs as { publication_number: string }),
+});

package/src/adapters/cnipa/legal-status.ts

@@ -0,0 +1,162 @@
+/**
+ * @owner       src::adapters::cnipa::legal-status
+ * @does        Browser-driven CNIPA legal-status lookup — scrapes the prosecution timeline + grant status from the 公众查询 detail page; emits structured envelopes for captcha / not-found / MCP-bus gaps.
+ * @needs       src/engine/transport/mcp-browser.ts, src/engine/normalizer/patent-envelope.ts, src/adapters/cnipa/_shared.ts, src/registry.ts
+ * @feeds       src/commands/patent.ts (capability tag patent.legal-status)
+ * @breaks      emits PATENT_INVALID_NUMBER, PATENT_BROWSER_CAPTCHA, PATENT_API_DEPRECATED (with MCP_BUS_MISSING context); never synthesizes a status
+ * @invariants  output row carries `legal_status` exactly as scraped; no normalization beyond trim
+ * @side-effects controls Chrome via MCP
+ * @perf        single navigate + evaluate
+ * @concurrency safe
+ * @test        tests/unit/adapters/cnipa/search.test.ts (shared transport-error path)
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification browser-only
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { TransportError } from "../../engine/transport/mcp-browser.js";
+import {
+  cnipaEnvelope,
+  looksLikeCaptcha,
+  navigateAndExtract,
+  transportErrorToEnvelope,
+} from "./_shared.js";
+
+const ADAPTER_PATH = "src/adapters/cnipa/legal-status.ts";
+const CNIPA_LEGAL_URL = "https://pss-system.cponline.cnipa.gov.cn/legalStatus";
+
+interface CnipaLegalRow {
+  publication_number: string;
+  legal_status?: string;
+  status_date?: string;
+  source_url?: string;
+  html_marker?: string;
+}
+
+const EXTRACTOR = `(() => {
+  const text = (sel) => {
+    const node = document.querySelector(sel);
+    return node ? (node.textContent || '').trim() : '';
+  };
+  return {
+    publication_number: text('[data-field="pubNo"], .publication-number'),
+    legal_status: text('[data-field="legalStatus"], .legal-status'),
+    status_date: text('[data-field="statusDate"], .status-date'),
+    source_url: location.href,
+    html_marker: document.body && document.body.innerText
+      ? document.body.innerText.slice(0, 200)
+      : '',
+  };
+})()`;
+
+export async function runCnipaLegalStatus(kwargs: {
+  publication_number: string;
+}): Promise<unknown[]> {
+  const pubNo = String(kwargs.publication_number ?? "").trim();
+  if (pubNo.length === 0) {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_INVALID_NUMBER",
+          ADAPTER_PATH,
+          "validate",
+          "cnipa legal-status requires a non-empty publication_number",
+        ),
+      },
+    ];
+  }
+  const url = `${CNIPA_LEGAL_URL}?pubNo=${encodeURIComponent(pubNo)}`;
+  let detail: CnipaLegalRow;
+  try {
+    const result = await navigateAndExtract<CnipaLegalRow>(url, EXTRACTOR);
+    if (!result.data) {
+      return [
+        {
+          envelope: cnipaEnvelope(
+            "PATENT_SCHEMA_DRIFT",
+            ADAPTER_PATH,
+            "evaluate",
+            "mcp-browser evaluate returned no data",
+          ),
+        },
+      ];
+    }
+    detail = result.data;
+  } catch (err) {
+    if (err instanceof TransportError) {
+      return [
+        {
+          envelope: transportErrorToEnvelope(err, ADAPTER_PATH, "navigate"),
+        },
+      ];
+    }
+    throw err;
+  }
+  const fieldCount = [detail.publication_number, detail.legal_status].filter(
+    Boolean,
+  ).length;
+  if (looksLikeCaptcha(fieldCount, detail.html_marker)) {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_BROWSER_CAPTCHA",
+          ADAPTER_PATH,
+          "evaluate",
+          "CNIPA legal-status page returned no fields; solve the 验证码 and re-run",
+          ["espacenet"],
+        ),
+      },
+    ];
+  }
+  if (!detail.legal_status) {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_NOT_FOUND",
+          ADAPTER_PATH,
+          "normalize",
+          `cnipa returned no legal_status for "${pubNo}"`,
+          ["espacenet"],
+        ),
+      },
+    ];
+  }
+  return [
+    {
+      publication_number: detail.publication_number || pubNo,
+      legal_status: detail.legal_status,
+      status_date: detail.status_date,
+      source_adapter: "cnipa",
+      source_url: detail.source_url || url,
+      retrieved_at: new Date().toISOString(),
+    },
+  ];
+}
+
+cli({
+  site: "cnipa",
+  name: "legal-status",
+  description: "CNIPA legal-status / prosecution timeline lookup (browser)",
+  domain: "pss-system.cponline.cnipa.gov.cn",
+  strategy: Strategy.PUBLIC,
+  adapter_path: ADAPTER_PATH,
+  args: [
+    {
+      name: "publication_number",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "ST.16 publication number",
+    },
+  ],
+  columns: ["publication_number", "legal_status", "status_date", "source_url"],
+  capabilities: [
+    "mcp-browser.navigate",
+    "mcp-browser.evaluate",
+    "patent.legal-status",
+  ],
+  minimum_capability: "mcp-browser.evaluate",
+  func: async (_page, kwargs) =>
+    runCnipaLegalStatus(kwargs as { publication_number: string }),
+});

package/src/adapters/cnipa/search.ts

@@ -0,0 +1,229 @@
+/**
+ * @owner       src::adapters::cnipa::search
+ * @does        Browser-driven search of CNIPA 公众查询 system at pss-system.cponline.cnipa.gov.cn — the only programmatic route for CN patents (CNIPA has no open API today). Drives a real Chrome session via the mcp-browser transport, extracts result rows, normalizes through assemblePatentRecord.
+ * @needs       src/engine/transport/mcp-browser.ts, src/engine/normalizer/patent-envelope.ts, src/types/patent.ts, src/adapters/cnipa/_shared.ts, src/registry.ts
+ * @feeds       src/commands/patent.ts (meta-command discovers via patent.search capability tag)
+ * @breaks      emits PATENT_BROWSER_CAPTCHA envelope when zero rows return from a navigation that did not error (CNIPA almost always shows a captcha gate); emits PATENT_API_DEPRECATED with MCP_BUS_MISSING context when no outbound MCP transport is registered
+ * @invariants  result rows always include source_adapter='cnipa'; publication_number canonicalized via assemblePatentRecord; never returns a synthetic row when extraction fails
+ * @side-effects controls the user's Chrome browser via MCP; reads no env vars
+ * @perf        single navigation + one evaluate; ~2-5 s wall-clock when active
+ * @concurrency safe — every call opens a fresh tab via mcpBrowserNavigate
+ * @test        tests/unit/adapters/cnipa/search.test.ts
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification browser-only — no upstream API; gated on a live mcp-browser transport
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { TransportError } from "../../engine/transport/mcp-browser.js";
+import { assemblePatentRecord } from "../../engine/normalizer/patent-envelope.js";
+import {
+  cnipaEnvelope,
+  looksLikeCaptcha,
+  navigateAndExtract,
+  transportErrorToEnvelope,
+} from "./_shared.js";
+
+const ADAPTER_PATH = "src/adapters/cnipa/search.ts";
+const CNIPA_SEARCH_URL =
+  "https://pss-system.cponline.cnipa.gov.cn/conventionalSearch";
+
+interface CnipaRow {
+  publication_number: string;
+  application_number?: string;
+  title?: string;
+  applicant?: string;
+  publication_date?: string;
+  filing_date?: string;
+  source_url?: string;
+}
+
+interface CnipaExtractResult {
+  rows: CnipaRow[];
+  html_marker?: string;
+}
+
+/**
+ * DOM extractor executed inside the page via mcp-browser. The selectors are
+ * the documented ones for the CNIPA 公众查询 result table; when CNIPA
+ * changes the markup an agent reads the failure envelope and updates the
+ * selector here (rule 02 self-repair).
+ */
+const EXTRACTOR = `(() => {
+  const rows = Array.from(
+    document.querySelectorAll('table.result-table tbody tr, .result-list .result-item')
+  ).map((el) => {
+    const text = (sel) => {
+      const node = el.querySelector(sel);
+      return node ? (node.textContent || '').trim() : '';
+    };
+    return {
+      publication_number: text('.publication-number, [data-field="pubNo"]'),
+      application_number: text('.application-number, [data-field="appNo"]'),
+      title: text('.title, [data-field="title"]'),
+      applicant: text('.applicant, [data-field="applicant"]'),
+      publication_date: text('.publication-date, [data-field="pubDate"]'),
+      filing_date: text('.filing-date, [data-field="appDate"]'),
+      source_url: (el.querySelector('a[href]') || {}).href || '',
+    };
+  });
+  const html_marker = (document.body && document.body.innerText
+    ? document.body.innerText.slice(0, 200)
+    : '');
+  return { rows, html_marker };
+})()`;
+
+function buildSearchUrl(query: string, limit: number, offset: number): string {
+  const params = new URLSearchParams({
+    q: query,
+    pageSize: String(limit),
+    pageNo: String(Math.floor(offset / Math.max(1, limit)) + 1),
+  });
+  return `${CNIPA_SEARCH_URL}?${params.toString()}`;
+}
+
+export async function runCnipaSearch(kwargs: {
+  query: string;
+  limit?: number;
+  offset?: number;
+}): Promise<unknown[]> {
+  const limit =
+    typeof kwargs.limit === "number" && Number.isFinite(kwargs.limit)
+      ? Math.max(1, Math.min(100, Math.floor(kwargs.limit)))
+      : 25;
+  const offset =
+    typeof kwargs.offset === "number" && Number.isFinite(kwargs.offset)
+      ? Math.max(0, Math.floor(kwargs.offset))
+      : 0;
+  const query = String(kwargs.query ?? "").trim();
+  if (query.length === 0) {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_UNSUPPORTED_QUERY",
+          ADAPTER_PATH,
+          "validate",
+          "cnipa search requires a non-empty query string",
+        ),
+      },
+    ];
+  }
+  const url = buildSearchUrl(query, limit, offset);
+  let extract: CnipaExtractResult;
+  try {
+    const result = await navigateAndExtract<CnipaExtractResult>(url, EXTRACTOR);
+    if (!result.data) {
+      return [
+        {
+          envelope: cnipaEnvelope(
+            "PATENT_SCHEMA_DRIFT",
+            ADAPTER_PATH,
+            "evaluate",
+            "mcp-browser evaluate returned no data; check selector schema in src/adapters/cnipa/search.ts",
+          ),
+        },
+      ];
+    }
+    extract = result.data;
+  } catch (err) {
+    if (err instanceof TransportError) {
+      return [
+        {
+          envelope: transportErrorToEnvelope(err, ADAPTER_PATH, "navigate"),
+        },
+      ];
+    }
+    throw err;
+  }
+
+  if (looksLikeCaptcha(extract.rows.length, extract.html_marker)) {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_BROWSER_CAPTCHA",
+          ADAPTER_PATH,
+          "evaluate",
+          "CNIPA returned no rows for a non-empty query; solve the 验证码 in the open browser tab and re-run",
+          ["espacenet", "lens"],
+        ),
+      },
+    ];
+  }
+
+  const out: unknown[] = [];
+  for (const row of extract.rows.slice(0, limit)) {
+    if (!row.publication_number) continue;
+    try {
+      out.push(
+        assemblePatentRecord({
+          publication_number: row.publication_number,
+          application_number: row.application_number || undefined,
+          title: row.title || undefined,
+          assignees: row.applicant
+            ? [{ name: row.applicant, country: "CN" }]
+            : undefined,
+          publication_date: row.publication_date || undefined,
+          filing_date: row.filing_date || undefined,
+          source_adapter: "cnipa",
+          source_url: row.source_url || url,
+        } as Parameters<typeof assemblePatentRecord>[0]),
+      );
+    } catch {
+      // Skip malformed row rather than synthesize — rule 02.
+    }
+  }
+  if (out.length === 0) {
+    out.push({
+      envelope: cnipaEnvelope(
+        "PATENT_NOT_FOUND",
+        ADAPTER_PATH,
+        "normalize",
+        "cnipa returned rows but none carried a publication_number; report as schema drift",
+        ["espacenet"],
+      ),
+    });
+  }
+  return out;
+}
+
+cli({
+  site: "cnipa",
+  name: "search",
+  description:
+    "Search CNIPA via the public 公众查询 browser interface (no API)",
+  domain: "pss-system.cponline.cnipa.gov.cn",
+  strategy: Strategy.PUBLIC,
+  adapter_path: ADAPTER_PATH,
+  args: [
+    {
+      name: "query",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "Free-text query — matched against title/abstract/claims",
+    },
+    {
+      name: "limit",
+      type: "int",
+      default: 25,
+      description: "Maximum results to return (1-100)",
+    },
+    {
+      name: "offset",
+      type: "int",
+      default: 0,
+      description: "Result offset for pagination",
+    },
+  ],
+  columns: ["publication_number", "title", "publication_date", "source_url"],
+  capabilities: [
+    "mcp-browser.navigate",
+    "mcp-browser.evaluate",
+    "patent.search",
+  ],
+  minimum_capability: "mcp-browser.evaluate",
+  func: async (_page, kwargs) =>
+    runCnipaSearch(
+      kwargs as { query: string; limit?: number; offset?: number },
+    ),
+});

package/src/adapters/danbooru/artists.yaml

@@ -0,0 +1,44 @@
+site: danbooru
+name: artists
+description: Search Danbooru artist records
+domain: danbooru.donmai.us
+type: web-api
+strategy: public
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Artist name
+  limit:
+    type: int
+    default: 20
+    description: Number of artists to return
+
+pipeline:
+  - fetch:
+      url: "https://danbooru.donmai.us/artists.json"
+      params:
+        "search[name]": "${{ args.query }}"
+        limit: "${{ args.limit }}"
+
+  - map:
+      rank: "${{ index + 1 }}"
+      id: "${{ item.id }}"
+      name: "${{ item.name }}"
+      group_name: "${{ item.group_name }}"
+      other_names: "${{ Array.isArray(item.other_names) ? item.other_names.join(', ') : '' }}"
+      is_banned: "${{ item.is_banned }}"
+      is_deleted: "${{ item.is_deleted }}"
+      url: "${{ 'https://danbooru.donmai.us/artists/' + item.id }}"
+
+columns: [rank, id, name, group_name, other_names, is_banned, is_deleted, url]
+
+# schema-v2 metadata — injected by `unicli migrate schema-v2`
+capabilities: ["http.fetch"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

package/src/adapters/danbooru/comments.yaml

@@ -0,0 +1,45 @@
+site: danbooru
+name: comments
+description: List Danbooru comments for a post
+domain: danbooru.donmai.us
+type: web-api
+strategy: public
+
+args:
+  post_id:
+    type: str
+    required: true
+    positional: true
+    description: Danbooru post ID
+    x-unicli-kind: id
+  limit:
+    type: int
+    default: 20
+    description: Number of comments to return
+
+pipeline:
+  - fetch:
+      url: "https://danbooru.donmai.us/comments.json"
+      params:
+        "search[post_id]": "${{ args.post_id }}"
+        limit: "${{ args.limit }}"
+
+  - map:
+      rank: "${{ index + 1 }}"
+      id: "${{ item.id }}"
+      post_id: "${{ item.post_id }}"
+      creator_id: "${{ item.creator_id }}"
+      score: "${{ item.score }}"
+      body: "${{ String(item.body || '').replace(/\\s+/g, ' ').trim() }}"
+      created_at: "${{ item.created_at }}"
+      is_deleted: "${{ item.is_deleted }}"
+
+columns: [rank, id, post_id, creator_id, score, body, created_at, is_deleted]
+
+# schema-v2 metadata — injected by `unicli migrate schema-v2`
+capabilities: ["http.fetch"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2