@zenalexa/unicli 0.219.0 → 0.220.1

package/src/adapters/aibase/news.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildExtractAibaseNewsJs,
+  mapAibaseNewsPayload,
+  requireNewsLimit,
+} from "./news.js";
+
+describe("aibase agent-facing news command", () => {
+  it("validates limits and exposes selector extraction code", () => {
+    expect(requireNewsLimit(undefined)).toBe(20);
+    expect(requireNewsLimit("50")).toBe(50);
+    expect(() => requireNewsLimit("0")).toThrow("limit must be");
+    expect(buildExtractAibaseNewsJs()).toContain("/zh/daily/");
+  });
+
+  it("maps extracted rows and rejects selector drift", () => {
+    expect(
+      mapAibaseNewsPayload(
+        {
+          ok: true,
+          rows: [
+            { title: " AI  news ", url: " https://www.aibase.com/zh/daily/1 " },
+            { title: "", url: "https://example.test/empty" },
+          ],
+        },
+        10,
+      ),
+    ).toEqual([
+      {
+        rank: 1,
+        title: "AI news",
+        url: "https://www.aibase.com/zh/daily/1",
+      },
+    ]);
+    expect(() =>
+      mapAibaseNewsPayload({ ok: false, reason: "selector-missing" }, 10),
+    ).toThrow("selector drift");
+    expect(() => mapAibaseNewsPayload({ ok: true, rows: [] }, 10)).toThrow(
+      "no article rows",
+    );
+  });
+});

package/src/adapters/aibase/news.ts

@@ -0,0 +1,118 @@
+/**
+ * @owner   src/adapters/aibase/news.ts
+ * @does    Register agent-facing AIbase daily-news browser extraction command.
+ * @needs   Public AIbase daily page, browser runtime, selector-drift error reporting.
+ * @feeds   surface coverage ledger, AI news discovery, Chinese AI daily brief surface.
+ * @breaks  AIbase DOM drift or silent empty extraction hides news coverage failures.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+
+const AIBASE_DAILY_URL = "https://www.aibase.com/zh/daily";
+
+function normalizeText(value: unknown): string {
+  return String(value ?? "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function requireNewsLimit(value: unknown, fallback = 20): number {
+  if (value === undefined || value === null || value === "") return fallback;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1 || n > 50) {
+    throw new Error("limit must be an integer in [1, 50].");
+  }
+  return n;
+}
+
+export function buildExtractAibaseNewsJs(): string {
+  return `
+    (() => {
+      const anchors = Array.from(document.querySelectorAll('.bg-white .grid a[href], a[href*="/zh/daily/"]'))
+        .filter((anchor) => {
+          const href = anchor.getAttribute('href') || '';
+          const text = (anchor.innerText || anchor.textContent || '').trim();
+          return text && href && !href.endsWith('/zh/daily') && !href.endsWith('/zh/daily/');
+        });
+      if (anchors.length === 0) {
+        return {
+          ok: false,
+          reason: 'selector-missing',
+          title: document.title || '',
+          bodyText: (document.body?.innerText || document.body?.textContent || '').slice(0, 500),
+        };
+      }
+      const seen = new Set();
+      const rows = [];
+      for (const anchor of anchors) {
+        const url = new URL(anchor.getAttribute('href'), location.href).href;
+        if (seen.has(url)) continue;
+        seen.add(url);
+        rows.push({
+          title: anchor.innerText || anchor.textContent || '',
+          url,
+        });
+      }
+      return { ok: true, rows };
+    })()
+  `;
+}
+
+interface BrowserExtractPayload {
+  ok?: unknown;
+  reason?: unknown;
+  title?: unknown;
+  rows?: Array<{ title?: unknown; url?: unknown }>;
+}
+
+export function mapAibaseNewsPayload(
+  payload: BrowserExtractPayload,
+  limit: number,
+): Array<Record<string, unknown>> {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("AIbase daily page returned an unreadable payload.");
+  }
+  if (payload.ok !== true) {
+    const reason = normalizeText(payload.reason) || "selector-drift";
+    const title = normalizeText(payload.title);
+    throw new Error(
+      `AIbase daily selector drift: ${reason}${title ? ` (${title})` : ""}`,
+    );
+  }
+  const rows = (Array.isArray(payload.rows) ? payload.rows : [])
+    .map((row, index) => ({
+      rank: index + 1,
+      title: normalizeText(row.title),
+      url: normalizeText(row.url),
+    }))
+    .filter((row) => row.title && row.url);
+  if (rows.length === 0) {
+    throw new Error(
+      "AIbase daily page loaded, but no article rows were extracted.",
+    );
+  }
+  return rows
+    .slice(0, limit)
+    .map((row, index) => ({ ...row, rank: index + 1 }));
+}
+
+cli({
+  site: "aibase",
+  name: "news",
+  description: "AIbase daily AI industry news",
+  domain: "www.aibase.com",
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [{ name: "limit", type: "int", default: 20, description: "Max rows" }],
+  columns: ["rank", "title", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const limit = requireNewsLimit(kwargs.limit);
+    await p.goto(AIBASE_DAILY_URL, { waitUntil: "load", settleMs: 3000 });
+    const payload = (await p.evaluate(
+      buildExtractAibaseNewsJs(),
+    )) as BrowserExtractPayload;
+    return mapAibaseNewsPayload(payload, limit);
+  },
+});

package/src/adapters/anilist/web.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest";
+import { resolveCommand } from "../../registry.js";
+import { mapAniListMedia, mapAniListNamed, rerankAniListNamed } from "./web.js";
+
+describe("anilist public commands", () => {
+  it("registers anime, manga, and entity commands", () => {
+    expect(
+      Object.keys(resolveCommand("anilist", "anime")!.adapter.commands),
+    ).toEqual(
+      expect.arrayContaining([
+        "anime",
+        "manga",
+        "characters",
+        "staff",
+        "studios",
+      ]),
+    );
+  });
+
+  it("exposes year and sort controls for recent media search", () => {
+    expect(resolveCommand("anilist", "anime")!.command.adapterArgs).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ name: "year", type: "int" }),
+        expect.objectContaining({
+          name: "sort",
+          choices: expect.arrayContaining(["popular", "trending", "recent"]),
+        }),
+      ]),
+    );
+  });
+
+  it("maps media rows", () => {
+    expect(
+      mapAniListMedia([
+        {
+          id: 102662,
+          title: { romaji: "Hanabi", native: "花火" },
+          type: "ANIME",
+          format: "MUSIC",
+          status: "FINISHED",
+          averageScore: 56,
+          popularity: 1059,
+          siteUrl: "https://anilist.co/anime/102662",
+        },
+      ]),
+    ).toMatchObject([
+      {
+        rank: 1,
+        id: 102662,
+        title: "Hanabi",
+        native: "花火",
+        type: "ANIME",
+        url: "https://anilist.co/anime/102662",
+      },
+    ]);
+  });
+
+  it("maps named rows", () => {
+    expect(
+      mapAniListNamed(
+        [
+          {
+            id: 1,
+            name: { full: "Yuzusoft", native: "" },
+            favourites: 9,
+            siteUrl: "https://anilist.co/studio/1",
+          },
+        ],
+        "studios",
+      ),
+    ).toMatchObject([{ rank: 1, id: 1, kind: "studios", name: "Yuzusoft" }]);
+  });
+
+  it("reranks native character matches ahead of popularity-only hits", () => {
+    const rows = rerankAniListNamed(
+      [
+        {
+          id: 1,
+          name: { full: "Levi", native: "リヴァイ" },
+          favourites: 40000,
+        },
+        {
+          id: 2,
+          name: { full: "Hanabi Yasuraoka", native: "安楽岡花火" },
+          favourites: 1500,
+        },
+      ],
+      "花火",
+    );
+
+    expect((rows[0] as { id: number }).id).toBe(2);
+  });
+});

package/src/adapters/anilist/web.ts

@@ -0,0 +1,341 @@
+/**
+ * @owner   src/adapters/anilist/web.ts
+ * @does    Register AniList public GraphQL search commands for anime, manga, characters, staff, and studios.
+ * @needs   AniList public GraphQL schema and rate-limited unauthenticated search.
+ * @feeds   ACG entity discovery across titles, characters, creators, and studios.
+ * @breaks  AniList GraphQL field or rate-limit changes can block search workflows.
+ */
+
+import { USER_AGENT } from "../../constants.js";
+import { cli, Strategy } from "../../registry.js";
+
+const API_URL = "https://graphql.anilist.co";
+
+function text(value: unknown, label: string): string {
+  const result = String(value ?? "").trim();
+  if (!result) throw new Error(`anilist ${label} cannot be empty.`);
+  return result;
+}
+
+function limit(value: unknown, fallback = 10): number {
+  if (value === undefined || value === null || value === "") return fallback;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1 || n > 50) {
+    throw new Error("anilist limit must be an integer in [1, 50].");
+  }
+  return n;
+}
+
+function optionalYear(value: unknown): number | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1900 || n > 2100) {
+    throw new Error("anilist year must be an integer in [1900, 2100].");
+  }
+  return n;
+}
+
+const MEDIA_SORTS: Record<string, string[]> = {
+  popular: ["POPULARITY_DESC"],
+  trending: ["TRENDING_DESC"],
+  recent: ["START_DATE_DESC"],
+  score: ["SCORE_DESC"],
+  relevance: ["SEARCH_MATCH"],
+};
+
+function mediaSort(value: unknown): string[] {
+  const key = String(value ?? "relevance").trim();
+  const sort = MEDIA_SORTS[key];
+  if (!sort) {
+    throw new Error(
+      `anilist sort must be one of: ${Object.keys(MEDIA_SORTS).join(", ")}.`,
+    );
+  }
+  return sort;
+}
+
+function str(value: unknown): string {
+  return value === undefined || value === null ? "" : String(value);
+}
+
+function title(value: unknown): string {
+  const obj =
+    value && typeof value === "object"
+      ? (value as Record<string, unknown>)
+      : {};
+  return str(obj.english) || str(obj.romaji) || str(obj.native);
+}
+
+async function postGraphql<T>(
+  query: string,
+  variables: Record<string, unknown>,
+): Promise<T> {
+  const response = await fetch(API_URL, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT,
+    },
+    body: JSON.stringify({ query, variables }),
+  });
+  if (!response.ok)
+    throw new Error(`anilist request failed with HTTP ${response.status}.`);
+  const data = (await response.json()) as {
+    data?: T;
+    errors?: Array<{ message?: string }>;
+  };
+  if (data.errors?.length) {
+    throw new Error(
+      `anilist API error: ${data.errors.map((e) => e.message).join("; ")}`,
+    );
+  }
+  if (!data.data) throw new Error("anilist response did not include data.");
+  return data.data;
+}
+
+export function mapAniListMedia(rows: unknown[]): Record<string, unknown>[] {
+  return rows.map((row, index) => {
+    const item = row as Record<string, unknown>;
+    return {
+      rank: index + 1,
+      id: item.id,
+      title: title(item.title),
+      native: str((item.title as Record<string, unknown> | undefined)?.native),
+      type: str(item.type),
+      format: str(item.format),
+      status: str(item.status),
+      score: item.averageScore ?? null,
+      popularity: item.popularity ?? null,
+      trending: item.trending ?? null,
+      start_date: formatDate(item.startDate),
+      episodes: item.episodes ?? null,
+      chapters: item.chapters ?? null,
+      url: str(item.siteUrl),
+    };
+  });
+}
+
+export function mapAniListNamed(
+  rows: unknown[],
+  kind: string,
+): Record<string, unknown>[] {
+  return rows.map((row, index) => {
+    const item = row as Record<string, unknown>;
+    const name = item.name as Record<string, unknown> | undefined;
+    return {
+      rank: index + 1,
+      id: item.id,
+      kind,
+      name: str(name?.full ?? item.name),
+      native: str(name?.native),
+      favourites: item.favourites ?? null,
+      url: str(item.siteUrl),
+    };
+  });
+}
+
+export function rerankAniListNamed(rows: unknown[], query: string): unknown[] {
+  const needle = query.trim().toLowerCase();
+  if (!needle) return rows;
+
+  return [...rows].sort((left, right) => {
+    const leftScore = namedMatchScore(left, needle);
+    const rightScore = namedMatchScore(right, needle);
+    if (leftScore !== rightScore) return rightScore - leftScore;
+    return 0;
+  });
+}
+
+function namedMatchScore(row: unknown, needle: string): number {
+  const item = row as Record<string, unknown>;
+  const name =
+    item.name && typeof item.name === "object"
+      ? (item.name as Record<string, unknown>)
+      : {};
+  const candidates = [item.name, name.full, name.native].map((value) =>
+    str(value).toLowerCase(),
+  );
+  if (candidates.some((value) => value === needle)) return 4;
+  if (candidates.some((value) => value.includes(needle))) return 3;
+  if (candidates.some((value) => needle.includes(value) && value.length > 1)) {
+    return 2;
+  }
+  return 0;
+}
+
+function formatDate(value: unknown): string {
+  const obj =
+    value && typeof value === "object"
+      ? (value as Record<string, unknown>)
+      : {};
+  const year = Number(obj.year);
+  if (!Number.isInteger(year) || year <= 0) return "";
+  const month = Number(obj.month);
+  const day = Number(obj.day);
+  if (!Number.isInteger(month) || month <= 0) return String(year);
+  if (!Number.isInteger(day) || day <= 0) {
+    return [String(year).padStart(4, "0"), String(month).padStart(2, "0")].join(
+      "-",
+    );
+  }
+  return [
+    String(year).padStart(4, "0"),
+    String(month).padStart(2, "0"),
+    String(day).padStart(2, "0"),
+  ].join("-");
+}
+
+async function searchMedia(
+  kind: "ANIME" | "MANGA",
+  kwargs: Record<string, unknown>,
+) {
+  const query = text(kwargs.query, "query");
+  const requested = limit(kwargs.limit);
+  const perPage = Math.min(50, Math.max(10, requested * 5));
+  const year = optionalYear(kwargs.year);
+  const startDateGreater = year ? year * 10000 + 101 : undefined;
+  const startDateLesser = year ? year * 10000 + 1231 : undefined;
+  const sort = mediaSort(kwargs.sort);
+  const data = await postGraphql<{
+    Page?: { media?: unknown[] };
+  }>(
+    `query ($search: String, $perPage: Int, $type: MediaType, $startDateGreater: FuzzyDateInt, $startDateLesser: FuzzyDateInt, $sort: [MediaSort]) {
+      Page(page: 1, perPage: $perPage) {
+        media(search: $search, type: $type, startDate_greater: $startDateGreater, startDate_lesser: $startDateLesser, sort: $sort) {
+          id title { romaji english native } type format status averageScore popularity trending startDate { year month day } episodes chapters siteUrl
+        }
+      }
+    }`,
+    {
+      search: query,
+      perPage,
+      type: kind,
+      startDateGreater,
+      startDateLesser,
+      sort,
+    },
+  );
+  const rows = mapAniListMedia((data.Page?.media ?? []).slice(0, requested));
+  if (rows.length === 0)
+    throw new Error(`No AniList ${kind.toLowerCase()} found for "${query}".`);
+  return rows;
+}
+
+async function searchNamed(
+  kind: "characters" | "staff" | "studios",
+  kwargs: Record<string, unknown>,
+) {
+  const query = text(kwargs.query, "query");
+  const requested = limit(kwargs.limit);
+  const perPage = Math.min(50, Math.max(10, requested * 5));
+  const field =
+    kind === "characters"
+      ? "characters"
+      : kind === "staff"
+        ? "staff"
+        : "studios";
+  const fields =
+    kind === "studios"
+      ? "id name favourites siteUrl"
+      : "id name { full native } favourites siteUrl";
+  const data = await postGraphql<{
+    Page?: Record<string, unknown[]>;
+  }>(
+    `query ($search: String, $perPage: Int) {
+      Page(page: 1, perPage: $perPage) {
+        ${field}(search: $search) { ${fields} }
+      }
+    }`,
+    { search: query, perPage },
+  );
+  const rows = mapAniListNamed(
+    rerankAniListNamed(data.Page?.[field] ?? [], query).slice(0, requested),
+    kind,
+  );
+  if (rows.length === 0)
+    throw new Error(`No AniList ${kind} found for "${query}".`);
+  return rows;
+}
+
+const MEDIA_ARGS = [
+  { name: "query", type: "str" as const, required: true, positional: true },
+  { name: "limit", type: "int" as const, default: 10 },
+  { name: "year", type: "int" as const },
+  {
+    name: "sort",
+    type: "str" as const,
+    default: "relevance",
+    choices: ["relevance", "popular", "trending", "recent", "score"],
+  },
+];
+
+const NAMED_ARGS = [
+  { name: "query", type: "str" as const, required: true, positional: true },
+  { name: "limit", type: "int" as const, default: 10 },
+];
+
+const MEDIA_COLUMNS = [
+  "rank",
+  "id",
+  "title",
+  "native",
+  "type",
+  "format",
+  "status",
+  "score",
+  "popularity",
+  "trending",
+  "start_date",
+  "url",
+];
+
+const NAMED_COLUMNS = [
+  "rank",
+  "id",
+  "kind",
+  "name",
+  "native",
+  "favourites",
+  "url",
+];
+
+cli({
+  site: "anilist",
+  name: "anime",
+  description:
+    "Search AniList anime by Japanese title, native title, romaji, alias, or keyword",
+  domain: "anilist.co",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: MEDIA_ARGS,
+  columns: MEDIA_COLUMNS,
+  func: async (_page, kwargs) => searchMedia("ANIME", kwargs),
+});
+
+cli({
+  site: "anilist",
+  name: "manga",
+  description:
+    "Search AniList manga by Japanese title, native title, romaji, alias, or keyword",
+  domain: "anilist.co",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: MEDIA_ARGS,
+  columns: MEDIA_COLUMNS,
+  func: async (_page, kwargs) => searchMedia("MANGA", kwargs),
+});
+
+for (const name of ["characters", "staff", "studios"] as const) {
+  cli({
+    site: "anilist",
+    name,
+    description: `Search AniList ${name} by Japanese name, native name, romaji, or alias`,
+    domain: "anilist.co",
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: NAMED_ARGS,
+    columns: NAMED_COLUMNS,
+    func: async (_page, kwargs) => searchNamed(name, kwargs),
+  });
+}

package/src/adapters/arxiv/download.yaml

@@ -0,0 +1,53 @@
+site: arxiv
+name: download
+description: Download an arXiv paper PDF by ID
+domain: export.arxiv.org
+type: web-api
+strategy: public
+
+args:
+  id:
+    type: str
+    required: true
+    positional: true
+    description: "arXiv paper ID (e.g. 1706.03762)"
+    x-unicli-kind: id
+  output:
+    type: str
+    default: "./arxiv-downloads"
+    description: Output directory
+    x-unicli-kind: path
+
+pipeline:
+  - fetch_text:
+      url: "https://export.arxiv.org/api/query?id_list=${{ args.id | urlencode }}"
+
+  - parse_rss:
+      fields:
+        id: id
+        title: title
+
+  - map:
+      id: "${{ item.id.replace(/^https?:\\/\\/arxiv\\.org\\/abs\\//, '').replace(/v\\d+$/, '') }}"
+      title: "${{ item.title.replace(/\\s+/g, ' ').trim() }}"
+      pdf: "${{ 'https://arxiv.org/pdf/' + item.id.replace(/^https?:\\/\\/arxiv\\.org\\/abs\\//, '').replace(/v\\d+$/, '') }}"
+
+  - assert:
+      condition: "data.length > 0"
+      message: "No arXiv paper found for the requested ID."
+
+  - download:
+      url: "${{ item.pdf }}"
+      dir: "${{ args.output }}"
+      filename: "${{ item.id }}.pdf"
+      type: document
+
+columns: [id, title, pdf, _download]
+
+# schema-v2 metadata — injected by `unicli migrate schema-v2`
+capabilities: ["http.fetch", "http.download"]
+minimum_capability: http.download
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2