@zenalexa/unicli 0.219.0 → 0.220.1

package/src/adapters/uisdc/news.ts

@@ -0,0 +1,111 @@
+/**
+ * @owner   src/adapters/uisdc/news.ts
+ * @does    Register agent-facing UISDC news browser extraction command.
+ * @needs   Public UISDC news page, browser runtime, selector-drift error reporting.
+ * @feeds   surface coverage ledger, design/AI news discovery, Chinese design news surface.
+ * @breaks  UISDC DOM drift or silent empty extraction hides news coverage failures.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+
+const UISDC_NEWS_URL = "https://www.uisdc.com/news";
+
+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 buildExtractUisdcNewsJs(): string {
+  return `
+    (() => {
+      const cards = Array.from(document.querySelectorAll(
+        '.news-list > .news-item:first-child > .item-content > .dubao-items > .dubao-item'
+      ));
+      if (cards.length === 0) {
+        return {
+          ok: false,
+          reason: 'selector-missing',
+          title: document.title || '',
+          bodyText: (document.body?.innerText || document.body?.textContent || '').slice(0, 500),
+        };
+      }
+      const rows = cards.map((el) => {
+        const anchor = el.querySelector('a[href]');
+        return {
+          title: el.querySelector('.dubao-title')?.textContent || '',
+          summary: el.querySelector('.dubao-content')?.textContent || '',
+          url: anchor ? new URL(anchor.getAttribute('href'), location.href).href : '',
+        };
+      });
+      return { ok: true, rows };
+    })()
+  `;
+}
+
+interface BrowserExtractPayload {
+  ok?: unknown;
+  reason?: unknown;
+  title?: unknown;
+  rows?: Array<{ title?: unknown; summary?: unknown; url?: unknown }>;
+}
+
+export function mapUisdcNewsPayload(
+  payload: BrowserExtractPayload,
+  limit: number,
+): Array<Record<string, unknown>> {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("UISDC news page returned an unreadable payload.");
+  }
+  if (payload.ok !== true) {
+    const reason = normalizeText(payload.reason) || "selector-drift";
+    const title = normalizeText(payload.title);
+    throw new Error(
+      `UISDC news selector drift: ${reason}${title ? ` (${title})` : ""}`,
+    );
+  }
+  const rows = (Array.isArray(payload.rows) ? payload.rows : [])
+    .map((row, index) => ({
+      rank: index + 1,
+      title: normalizeText(row.title),
+      summary: normalizeText(row.summary),
+      url: normalizeText(row.url),
+    }))
+    .filter((row) => row.title && row.url);
+  if (rows.length === 0) {
+    throw new Error("UISDC news page loaded, but no news rows were extracted.");
+  }
+  return rows
+    .slice(0, limit)
+    .map((row, index) => ({ ...row, rank: index + 1 }));
+}
+
+cli({
+  site: "uisdc",
+  name: "news",
+  description: "UISDC latest AI and design news",
+  domain: "www.uisdc.com",
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [{ name: "limit", type: "int", default: 20, description: "Max rows" }],
+  columns: ["rank", "title", "summary", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const limit = requireNewsLimit(kwargs.limit);
+    await p.goto(UISDC_NEWS_URL, { waitUntil: "load", settleMs: 3000 });
+    const payload = (await p.evaluate(
+      buildExtractUisdcNewsJs(),
+    )) as BrowserExtractPayload;
+    return mapUisdcNewsPayload(payload, limit);
+  },
+});

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

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import { resolveCommand } from "../../registry.js";
+import { mapVndbReleases, mapVndbVisualNovels } from "./web.js";
+
+describe("vndb public commands", () => {
+  it("registers core visual novel discovery commands", () => {
+    expect(
+      Object.keys(resolveCommand("vndb", "search")!.adapter.commands),
+    ).toEqual(
+      expect.arrayContaining([
+        "search",
+        "vn",
+        "releases",
+        "tags",
+        "staff",
+        "producers",
+        "characters",
+      ]),
+    );
+  });
+
+  it("maps visual novel search rows with tags and developers", () => {
+    expect(
+      mapVndbVisualNovels([
+        {
+          id: "v57439",
+          title: "Hanabi no Sakase Kata",
+          alttitle: "花火の咲かせ方",
+          released: "2017-12-29",
+          languages: ["ja"],
+          platforms: ["win"],
+          rating: 70,
+          votecount: 10,
+          image: { url: "https://t.vndb.org/cv/70/112070.jpg" },
+          developers: [{ name: "Ultimate Manju" }],
+          tags: [
+            { name: "Comedy", rating: 1 },
+            { name: "ADV", rating: 2 },
+          ],
+        },
+      ]),
+    ).toEqual([
+      {
+        rank: 1,
+        id: "v57439",
+        title: "Hanabi no Sakase Kata",
+        alttitle: "花火の咲かせ方",
+        released: "2017-12-29",
+        languages: "ja",
+        platforms: "win",
+        rating: 70,
+        votecount: 10,
+        developers: "Ultimate Manju",
+        tags: "ADV, Comedy",
+        image: "https://t.vndb.org/cv/70/112070.jpg",
+        url: "https://vndb.org/v57439",
+      },
+    ]);
+  });
+
+  it("maps release rows", () => {
+    expect(
+      mapVndbReleases([
+        {
+          id: "r91050",
+          title: "U-ena -Toohanabi no Shoujo-",
+          released: "TBA",
+          platforms: ["win"],
+          producers: [{ name: "Hemiola Studio" }],
+          vns: [{ title: "U-ena -Toohanabi no Shoujo-" }],
+        },
+      ]),
+    ).toEqual([
+      {
+        rank: 1,
+        id: "r91050",
+        title: "U-ena -Toohanabi no Shoujo-",
+        released: "TBA",
+        platforms: "win",
+        producers: "Hemiola Studio",
+        vns: "U-ena -Toohanabi no Shoujo-",
+        url: "https://vndb.org/r91050",
+      },
+    ]);
+  });
+});

package/src/adapters/vndb/web.ts

@@ -0,0 +1,393 @@
+/**
+ * @owner   src/adapters/vndb/web.ts
+ * @does    Register VNDB public visual novel, release, tag, staff, producer, and character lookup commands.
+ * @needs   VNDB Kana API JSON contract and public unauthenticated read endpoints.
+ * @feeds   ACG research workflows, visual novel discovery, game tag/type search.
+ * @breaks  VNDB field names or filter semantics drifting will hide games or metadata.
+ */
+
+import { USER_AGENT } from "../../constants.js";
+import { cli, Strategy } from "../../registry.js";
+
+const VNDB_API = "https://api.vndb.org/kana";
+
+interface VndbResponse {
+  more?: boolean;
+  results?: Record<string, unknown>[];
+}
+
+function str(value: unknown): string {
+  return value === undefined || value === null ? "" : String(value);
+}
+
+function requireQuery(value: unknown): string {
+  const query = str(value).trim();
+  if (!query) throw new Error("VNDB query cannot be empty.");
+  return query;
+}
+
+function requireLimit(value: unknown, fallback = 20): number {
+  if (value === undefined || value === null || value === "") return fallback;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1 || n > 100) {
+    throw new Error("VNDB limit must be an integer in [1, 100].");
+  }
+  return n;
+}
+
+function normalizeId(value: unknown, prefix: string): string {
+  const raw = str(value).trim().toLowerCase();
+  if (!raw) throw new Error("VNDB id cannot be empty.");
+  return raw.startsWith(prefix) ? raw : `${prefix}${raw}`;
+}
+
+function joinNames(value: unknown, key = "name"): string {
+  return Array.isArray(value)
+    ? value
+        .map((item) => str((item as Record<string, unknown>)[key]))
+        .join(", ")
+    : "";
+}
+
+function joinStrings(value: unknown): string {
+  return Array.isArray(value) ? value.map(String).join(", ") : str(value);
+}
+
+function firstUrl(value: unknown): string {
+  if (!value || typeof value !== "object") return "";
+  return str((value as Record<string, unknown>).url);
+}
+
+function tagSummary(value: unknown): string {
+  if (!Array.isArray(value)) return "";
+  return value
+    .slice()
+    .sort(
+      (a, b) =>
+        Number((b as Record<string, unknown>).rating ?? 0) -
+        Number((a as Record<string, unknown>).rating ?? 0),
+    )
+    .slice(0, 12)
+    .map((item) => str((item as Record<string, unknown>).name))
+    .filter(Boolean)
+    .join(", ");
+}
+
+function sortValue(value: unknown, allowed: Record<string, string>): string {
+  const key = str(value || "relevance")
+    .toLowerCase()
+    .replace(/[\s_-]+/g, "");
+  const mapped = allowed[key];
+  if (!mapped) {
+    throw new Error(
+      `Unsupported VNDB sort: ${value}. Supported: ${Object.keys(allowed).join(", ")}.`,
+    );
+  }
+  return mapped;
+}
+
+async function vndbPost(
+  endpoint: string,
+  body: Record<string, unknown>,
+): Promise<Record<string, unknown>[]> {
+  const response = await fetch(`${VNDB_API}/${endpoint}`, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT,
+    },
+    body: JSON.stringify(body),
+  });
+  if (!response.ok) {
+    throw new Error(
+      `VNDB ${endpoint} request failed with HTTP ${response.status}.`,
+    );
+  }
+  const json = (await response.json()) as VndbResponse;
+  return json.results ?? [];
+}
+
+function rankRows(rows: Record<string, unknown>[]): Record<string, unknown>[] {
+  return rows.map((row, index) => ({ rank: index + 1, ...row }));
+}
+
+export function mapVndbVisualNovels(
+  rows: Record<string, unknown>[],
+): Record<string, unknown>[] {
+  return rankRows(
+    rows.map((item) => ({
+      id: str(item.id),
+      title: str(item.title),
+      alttitle: str(item.alttitle),
+      released: str(item.released),
+      languages: joinStrings(item.languages),
+      platforms: joinStrings(item.platforms),
+      rating: item.rating ?? "",
+      votecount: item.votecount ?? "",
+      developers: joinNames(item.developers),
+      tags: tagSummary(item.tags),
+      image: firstUrl(item.image),
+      url: `https://vndb.org/${str(item.id)}`,
+    })),
+  );
+}
+
+export function mapVndbReleases(
+  rows: Record<string, unknown>[],
+): Record<string, unknown>[] {
+  return rankRows(
+    rows.map((item) => ({
+      id: str(item.id),
+      title: str(item.title),
+      released: str(item.released),
+      platforms: joinStrings(item.platforms),
+      producers: joinNames(item.producers),
+      vns: joinNames(item.vns, "title"),
+      url: `https://vndb.org/${str(item.id)}`,
+    })),
+  );
+}
+
+function mapSimple(
+  rows: Record<string, unknown>[],
+  urlPrefix: string,
+): Record<string, unknown>[] {
+  return rankRows(
+    rows.map((item) => ({
+      id: str(item.id),
+      name: str(item.name),
+      original: str(item.original),
+      category: str(item.category),
+      type: str(item.type),
+      lang: str(item.lang),
+      aliases: joinStrings(item.aliases),
+      description: str(item.description).replace(/\s+/g, " ").slice(0, 500),
+      url: `https://vndb.org/${urlPrefix}${str(item.id).replace(/^[a-z]+/, "")}`,
+    })),
+  );
+}
+
+async function searchVn(kwargs: Record<string, unknown>) {
+  const sort = sortValue(kwargs.sort, {
+    relevance: "searchrank",
+    rating: "rating",
+    votes: "votecount",
+    votecount: "votecount",
+    released: "released",
+    time: "released",
+    title: "title",
+  });
+  const rows = await vndbPost("vn", {
+    filters: ["search", "=", requireQuery(kwargs.query)],
+    fields:
+      "id,title,alttitle,released,languages,platforms,rating,votecount,image.url,tags.rating,tags.name,tags.category,developers.name",
+    sort,
+    reverse: kwargs.reverse === true,
+    results: requireLimit(kwargs.limit),
+  });
+  return mapVndbVisualNovels(rows);
+}
+
+const VN_COLUMNS = [
+  "rank",
+  "id",
+  "title",
+  "alttitle",
+  "released",
+  "languages",
+  "platforms",
+  "rating",
+  "votecount",
+  "developers",
+  "tags",
+  "url",
+];
+
+cli({
+  site: "vndb",
+  name: "search",
+  description: "Search VNDB visual novels by title, alias, tag, or keyword",
+  domain: "api.vndb.org",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 20 },
+    {
+      name: "sort",
+      type: "str",
+      default: "relevance",
+      description: "relevance, rating, votes, released, time, title",
+    },
+    { name: "reverse", type: "bool", default: false },
+  ],
+  columns: VN_COLUMNS,
+  func: async (_page, kwargs) => searchVn(kwargs),
+});
+
+cli({
+  site: "vndb",
+  name: "vn",
+  description: "Get VNDB visual novel details by v-id",
+  domain: "api.vndb.org",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [{ name: "id", type: "str", required: true, positional: true }],
+  columns: VN_COLUMNS,
+  func: async (_page, kwargs) =>
+    mapVndbVisualNovels(
+      await vndbPost("vn", {
+        filters: ["id", "=", normalizeId(kwargs.id, "v")],
+        fields:
+          "id,title,alttitle,released,languages,platforms,rating,votecount,image.url,tags.rating,tags.name,tags.category,developers.name",
+        results: 1,
+      }),
+    ),
+});
+
+cli({
+  site: "vndb",
+  name: "releases",
+  description: "Search VNDB releases by title or visual novel keyword",
+  domain: "api.vndb.org",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 20 },
+    {
+      name: "sort",
+      type: "str",
+      default: "released",
+      description: "released, time, title",
+    },
+    { name: "reverse", type: "bool", default: true },
+  ],
+  columns: [
+    "rank",
+    "id",
+    "title",
+    "released",
+    "platforms",
+    "producers",
+    "vns",
+    "url",
+  ],
+  func: async (_page, kwargs) =>
+    mapVndbReleases(
+      await vndbPost("release", {
+        filters: ["search", "=", requireQuery(kwargs.query)],
+        fields: "id,title,released,platforms,producers.name,vns.title",
+        sort: sortValue(kwargs.sort, {
+          released: "released",
+          time: "released",
+          title: "title",
+        }),
+        reverse: kwargs.reverse !== false,
+        results: requireLimit(kwargs.limit),
+      }),
+    ),
+});
+
+cli({
+  site: "vndb",
+  name: "tags",
+  description: "Search VNDB game tags and genres",
+  domain: "api.vndb.org",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 20 },
+  ],
+  columns: ["rank", "id", "name", "category", "description", "url"],
+  func: async (_page, kwargs) =>
+    mapSimple(
+      await vndbPost("tag", {
+        filters: ["search", "=", requireQuery(kwargs.query)],
+        fields: "id,name,category,description",
+        results: requireLimit(kwargs.limit),
+      }),
+      "g",
+    ),
+});
+
+cli({
+  site: "vndb",
+  name: "staff",
+  description: "Search VNDB creators and staff",
+  domain: "api.vndb.org",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 20 },
+  ],
+  columns: ["rank", "id", "name", "original", "lang", "description", "url"],
+  func: async (_page, kwargs) =>
+    mapSimple(
+      await vndbPost("staff", {
+        filters: ["search", "=", requireQuery(kwargs.query)],
+        fields: "id,name,original,lang,gender,description",
+        results: requireLimit(kwargs.limit),
+      }),
+      "s",
+    ),
+});
+
+cli({
+  site: "vndb",
+  name: "producers",
+  description:
+    "Search VNDB producers, studios, brands, makers, circles, companies, and visual novel publishers such as Yuzusoft",
+  domain: "api.vndb.org",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 20 },
+  ],
+  columns: [
+    "rank",
+    "id",
+    "name",
+    "aliases",
+    "lang",
+    "type",
+    "description",
+    "url",
+  ],
+  func: async (_page, kwargs) =>
+    mapSimple(
+      await vndbPost("producer", {
+        filters: ["search", "=", requireQuery(kwargs.query)],
+        fields: "id,name,aliases,lang,type,description",
+        results: requireLimit(kwargs.limit),
+      }),
+      "p",
+    ),
+});
+
+cli({
+  site: "vndb",
+  name: "characters",
+  description: "Search VNDB characters and traits",
+  domain: "api.vndb.org",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 20 },
+  ],
+  columns: ["rank", "id", "name", "original", "description", "url"],
+  func: async (_page, kwargs) =>
+    mapSimple(
+      await vndbPost("character", {
+        filters: ["search", "=", requireQuery(kwargs.query)],
+        fields: "id,name,original,sex,description,vns.title,traits.name",
+        results: requireLimit(kwargs.limit),
+      }),
+      "c",
+    ),
+});