@zenalexa/unicli 0.225.1 → 0.225.3

package/src/adapters/dblp/publications.test.ts

@@ -53,14 +53,18 @@ describe("dblp agent-facing publication commands", () => {
         1,
       ),
     ).toEqual({
+      id: "conf/nips/Paper24",
       rank: 1,
       key: "conf/nips/Paper24",
+      dblp_key: "conf/nips/Paper24",
       title: "A Paper",
       authors: "Jane Doe",
       venue: "NeurIPS",
       year: "2024",
       type: "conf",
       doi: "10.0000/test",
+      source_url: "https://doi.org/10.0000/test",
+      landing_url: "https://dblp.org/rec/conf/nips/Paper24.html",
       url: "https://doi.org/10.0000/test",
     });
   });
@@ -81,7 +85,9 @@ describe("dblp agent-facing publication commands", () => {
       </dblp>
     `;
     expect(mapRecordXml(xml)).toEqual({
+      id: "conf/nips/Paper24",
       key: "conf/nips/Paper24",
+      dblp_key: "conf/nips/Paper24",
       type: "conf",
       title: "A Paper",
       authors: "Jane Doe, Max & Co",
@@ -90,7 +96,10 @@ describe("dblp agent-facing publication commands", () => {
       pages: "1-10",
       doi: "10.0000/test",
       open_access_url: "https://openaccess.example/paper",
+      source_url: "https://openaccess.example/paper",
+      landing_url: "https://dblp.org/rec/conf/nips/Paper24.html",
       dblp_url: "https://dblp.org/rec/conf/nips/Paper24.html",
+      url: "https://openaccess.example/paper",
     });
     expect(
       splitAuthorRecords(

package/src/adapters/dblp/publications.ts

@@ -1,9 +1,16 @@
 /**
- * @owner   src/adapters/dblp/publications.ts
- * @does    Register agent-facing dblp publication, author, paper, and venue commands.
- * @needs   dblp public JSON/XML APIs, conservative XML field extraction, bounded result limits.
- * @feeds   surface coverage ledger, scholarly search surface, CS bibliography inspection.
- * @breaks  dblp API envelope drift, record-key parsing, or silent empty rows hide bibliography lookup failures.
+ * @owner       src::adapters::dblp::publications
+ * @does        Registers DBLP publication, paper, author, and venue commands for computer-science bibliography discovery.
+ * @needs       dblp public JSON/XML APIs, conservative XML field extraction, bounded result limits, src/registry.ts
+ * @feeds       src/commands/scholar.ts via scholar.search, scholar.get, scholar.pdf, scholar.author, and scholar.venue
+ * @breaks      DBLP API envelope drift, record-key parsing drift, or missing normalized ids makes CS bibliography rows invisible to the scholar meta-command.
+ * @invariants  DBLP `key` is the source-local scholarly id and is mirrored as `dblp_key`; DOI remains a separate cross-source dedupe key.
+ * @side-effects HTTPS egress to dblp.org only
+ * @perf        O(limit) JSON/XML mapping after one DBLP API request per command
+ * @concurrency safe
+ * @test        src/adapters/dblp/publications.test.ts; live smoke via `unicli dblp search <query>` and `unicli scholar doctor --sources dblp --live`
+ * @stability   experimental
+ * @since       2026-05-19
  */
 
 import { cli, Strategy } from "../../registry.js";
@@ -149,16 +156,21 @@ export function mapPublicationHit(
 ): Record<string, unknown> {
   const info = hit.info ?? {};
   const key = stringField(info.key);
+  const url = stringField(info.ee) || stringField(info.url);
   return {
+    id: key,
     rank,
     key,
+    dblp_key: key,
     title: stripTrailingDot(decodeXmlEntities(info.title)).trim(),
     authors: normalizeDblpAuthors(info.authors).join(", "),
     venue: decodeXmlEntities(info.venue),
     year: stringField(info.year),
     type: compactType(info.type),
     doi: stringField(info.doi),
-    url: stringField(info.ee) || stringField(info.url),
+    source_url: url || (key ? `${DBLP_ORIGIN}/rec/${key}.html` : ""),
+    landing_url: key ? `${DBLP_ORIGIN}/rec/${key}.html` : "",
+    url,
   };
 }
 
@@ -240,8 +252,12 @@ export function mapRecordXml(xml: string): Record<string, unknown> {
     .map(decodeXmlEntities)
     .find((value) => /(?:doi\.org\/|^10\.)/i.test(value));
   const doi = ee ? ee.replace(/^https?:\/\/(?:dx\.)?doi\.org\//i, "") : "";
+  const openAccessUrl = extractOpenAccessUrl(xml);
+  const dblpUrl = key ? `${DBLP_ORIGIN}/rec/${key}.html` : "";
   return {
+    id: key,
     key,
+    dblp_key: key,
     type,
     title: stripTrailingDot(decodeXmlEntities(extractFirst(xml, "title"))),
     authors: extractAll(xml, "author")
@@ -252,8 +268,11 @@ export function mapRecordXml(xml: string): Record<string, unknown> {
     year: decodeXmlEntities(extractFirst(xml, "year")),
     pages: decodeXmlEntities(extractFirst(xml, "pages")),
     doi: doi.startsWith("10.") ? doi : "",
-    open_access_url: extractOpenAccessUrl(xml),
-    dblp_url: key ? `${DBLP_ORIGIN}/rec/${key}.html` : "",
+    open_access_url: openAccessUrl,
+    source_url: openAccessUrl || dblpUrl,
+    landing_url: dblpUrl,
+    dblp_url: dblpUrl,
+    url: openAccessUrl || dblpUrl,
   };
 }
 
@@ -482,8 +501,10 @@ cli({
     return records.slice(0, limit).map((record, index) => {
       const row = mapRecordXml(`<root>${record}</root>`);
       return {
+        id: row.id || row.key || extractRecordKey(record),
         rank: index + 1,
         key: row.key || extractRecordKey(record),
+        dblp_key: row.dblp_key || row.key || extractRecordKey(record),
         title: row.title,
         authors: row.authors,
         venue: row.venue,
@@ -491,6 +512,8 @@ cli({
         type: row.type,
         doi: row.doi,
         pid,
+        source_url: row.source_url,
+        landing_url: row.landing_url,
         url: row.open_access_url || row.dblp_url,
       };
     });

package/src/adapters/defuddle/read.yaml

@@ -0,0 +1,30 @@
+site: defuddle
+name: read
+description: Read a public URL through defuddle.md and return Markdown with frontmatter
+type: web-api
+domain: defuddle.md
+strategy: public
+
+args:
+  url:
+    type: str
+    required: true
+    positional: true
+    description: Public URL to convert to Markdown
+    format: uri
+
+pipeline:
+  - fetch_text:
+      url: "https://defuddle.md/${{ args.url }}"
+      headers:
+        Accept: "text/markdown"
+
+columns: []
+
+# 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/google-scholar/search.ts

@@ -1,7 +1,143 @@
+/**
+ * @owner       src::adapters::google-scholar::search
+ * @does        Registers Google Scholar public browser search as a broad discovery source for scholarly metadata.
+ * @needs       scholar.google.com result DOM, src/registry.ts, src/types.ts, browser tools
+ * @feeds       src/commands/scholar.ts capability discovery, `unicli google-scholar search`, `unicli scholar search/doctor`
+ * @breaks      Google Scholar CAPTCHA/traffic blocks surface as upstream_blocked; result DOM drift can return empty rows instead of normalized scholarly records.
+ * @invariants  Search is metadata discovery only; result links are source hints, not full-text proof; publication years must be standalone years, never substrings of arXiv IDs.
+ * @side-effects Navigates a Uni-CLI managed browser page to Google Scholar public search.
+ * @perf        O(limit) DOM extraction after one page navigation.
+ * @concurrency safe — command state is page-local
+ * @test        tests/unit/adapters/scholar-sources.test.ts; live smoke via `unicli google-scholar search <query>` and `unicli scholar doctor --sources google-scholar --live`
+ * @stability   experimental
+ * @since       2026-06-27
+ */
+
 import { cli, Strategy } from "../../registry.js";
 import type { IPage } from "../../types.js";
 import { intArg, js, str } from "../_shared/browser-tools.js";
 
+interface GoogleScholarRawRow {
+  rank?: unknown;
+  title?: unknown;
+  infoLine?: unknown;
+  citedText?: unknown;
+  url?: unknown;
+}
+
+interface GoogleScholarBrowserPayload {
+  blocked?: boolean;
+  block_reason?: unknown;
+  rows?: unknown;
+}
+
+type GoogleScholarActionableError = Error & {
+  code?: string;
+  suggestion?: string;
+  retryable?: boolean;
+};
+
+export function buildGoogleScholarSearchUrl(query: string): string {
+  return `https://scholar.google.com/scholar?q=${encodeURIComponent(query)}&hl=en`;
+}
+
+export function parseGoogleScholarYear(infoLine: string): number | undefined {
+  for (const match of infoLine.matchAll(/(^|[^\d])((?:19|20)\d{2})(?!\d)/g)) {
+    const year = Number(match[2]);
+    if (Number.isInteger(year)) return year;
+  }
+  return undefined;
+}
+
+export function parseGoogleScholarInfoLine(infoLine: string): {
+  authors?: string;
+  venue?: string;
+  year?: number;
+} {
+  const parts = infoLine.split(" - ");
+  const authors = parts[0]?.trim() || undefined;
+  const detail = parts[1]?.trim() || "";
+  const detailParts = detail.split(",");
+  const venue =
+    detailParts.slice(0, -1).join(",").trim() ||
+    detailParts[0]?.trim() ||
+    undefined;
+  return {
+    authors,
+    venue,
+    year: parseGoogleScholarYear(infoLine),
+  };
+}
+
+export function googleScholarRecordId(
+  title: string,
+  sourceUrl: string,
+): string {
+  if (sourceUrl) {
+    try {
+      const parsed = new URL(sourceUrl);
+      if (parsed.hostname === "arxiv.org") {
+        const arxivId = parsed.pathname
+          .replace(/^\/(?:abs|pdf)\//, "")
+          .replace(/\.pdf$/i, "")
+          .replace(/v\d+$/i, "");
+        if (/^\d{4}\.\d{4,5}$/.test(arxivId)) return arxivId;
+      }
+      if (parsed.hostname === "doi.org") {
+        const doi = decodeURIComponent(parsed.pathname.replace(/^\//, ""));
+        if (doi) return doi;
+      }
+    } catch {
+      return sourceUrl;
+    }
+    return sourceUrl;
+  }
+  return title;
+}
+
+function normalize(value: unknown): string {
+  return String(value ?? "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function googleScholarBlockedError(
+  reason: string,
+): GoogleScholarActionableError {
+  const error = new Error(
+    `Google Scholar blocked the public browser search: ${reason}.`,
+  ) as GoogleScholarActionableError;
+  error.code = "upstream_blocked";
+  error.suggestion =
+    "Retry later, import a usable browser session, or use first-source alternatives such as semantic-scholar/openalex/crossref/arxiv for non-hallucinated scholarly lookup.";
+  error.retryable = true;
+  return error;
+}
+
+function mapGoogleScholarRow(
+  raw: GoogleScholarRawRow,
+): Record<string, unknown> | undefined {
+  const title = normalize(raw.title);
+  if (!title) return undefined;
+  const sourceUrl = normalize(raw.url);
+  const info = parseGoogleScholarInfoLine(normalize(raw.infoLine));
+  const citedText = normalize(raw.citedText);
+  const citedByCount = Number(citedText.match(/\d+/)?.[0] ?? 0);
+  return {
+    id: googleScholarRecordId(title, sourceUrl),
+    rank: Number(raw.rank) || undefined,
+    title,
+    authors: info.authors,
+    source: info.venue,
+    venue: info.venue,
+    year: info.year,
+    cited: String(citedByCount),
+    cited_by_count: citedByCount,
+    source_url: sourceUrl || undefined,
+    url: sourceUrl || undefined,
+  };
+}
+
 cli({
   site: "google-scholar",
   name: "search",
@@ -22,14 +158,25 @@ cli({
   func: async (page, kwargs) => {
     const p = page as IPage;
     const limit = intArg(kwargs.limit, 10, 20);
-    await p.goto(
-      `https://scholar.google.com/scholar?q=${encodeURIComponent(str(kwargs.query))}&hl=en`,
-      { settleMs: 2500 },
-    );
-    const rows = await p.evaluate(`(() => {
+    await p.goto(buildGoogleScholarSearchUrl(str(kwargs.query)), {
+      settleMs: 2500,
+    });
+    const payload = (await p.evaluate(`(() => {
       const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
-      const rows = [];
+      const bodyText = normalize(document.body?.innerText || document.body?.textContent || '');
+      const blocked =
+        location.pathname.includes('/sorry/') ||
+        document.querySelector('form[action*="/sorry/"], input[name="captcha"], #gs_captcha_ccl, iframe[src*="recaptcha"]') ||
+        /unusual traffic|not a robot|captcha/i.test(bodyText);
+      if (blocked) {
+        return {
+          blocked: true,
+          block_reason: document.title || bodyText.slice(0, 160) || location.href,
+          rows: []
+        };
+      }
       const seen = new Set();
+      const rows = [];
       const cards = [...document.querySelectorAll('.gs_r.gs_or.gs_scl, .gs_r.gs_or')];
       for (const card of cards) {
         const body = card.querySelector('.gs_ri') || card;
@@ -41,23 +188,24 @@ cli({
         if (seen.has(dedupeKey)) continue;
         seen.add(dedupeKey);
 
-        const infoLine = normalize(body.querySelector('.gs_a')?.textContent);
-        const parts = infoLine.split(' - ');
-        const sourceParts = (parts[1] || '').split(',');
         const citedText = normalize(body.querySelector('.gs_fl a[href*="cites"]')?.textContent);
         rows.push({
           rank: rows.length + 1,
           title,
-          authors: (parts[0] || '').trim(),
-          source: sourceParts.slice(0, -1).join(',').trim() || sourceParts[0]?.trim() || '',
-          year: infoLine.match(/(19|20)\\d{2}/)?.[0] || '',
-          cited: citedText.match(/(\\d+)/)?.[1] || '0',
-          url,
+          infoLine: normalize(body.querySelector('.gs_a')?.textContent),
+          citedText,
+          url
         });
         if (rows.length >= ${js(limit)}) break;
       }
-      return rows;
-    })()`);
-    return Array.isArray(rows) ? (rows as Record<string, unknown>[]) : [];
+      return { blocked: false, rows };
+    })()`)) as GoogleScholarBrowserPayload;
+    if (payload.blocked) {
+      throw googleScholarBlockedError(normalize(payload.block_reason));
+    }
+    if (!Array.isArray(payload.rows)) return [];
+    return payload.rows
+      .map((row) => mapGoogleScholarRow(row as GoogleScholarRawRow))
+      .filter((row): row is Record<string, unknown> => row !== undefined);
   },
 });

package/src/adapters/hf/paper.test.ts

@@ -27,6 +27,15 @@ describe("hf agent-facing paper command", () => {
           ai_keywords: ["transformer", "attention"],
           summary: "Paper summary",
           ai_summary: "AI summary",
+          githubRepo: "https://github.com/example/transformer",
+          githubStars: 42,
+          projectPage: "https://example.org/transformer",
+          linkedModels: [{ id: "org/model-a" }],
+          linkedDatasets: [{ id: "org/dataset-a" }],
+          linkedSpaces: [{ id: "org/space-a" }],
+          numTotalModels: 1,
+          numTotalDatasets: 1,
+          numTotalSpaces: 1,
         },
         "https://hf.example/",
       ),
@@ -39,6 +48,19 @@ describe("hf agent-facing paper command", () => {
       aiKeywords: "transformer, attention",
       summary: "Paper summary",
       aiSummary: "AI summary",
+      arxiv_id: "1706.03762",
+      pdf_url: "https://arxiv.org/pdf/1706.03762",
+      source_url: "https://hf.example/papers/1706.03762",
+      code_url: "https://github.com/example/transformer",
+      github_stars: 42,
+      project_url: "https://example.org/transformer",
+      dataset_url: "https://hf.example/datasets/org/dataset-a",
+      model_urls: "https://hf.example/org/model-a",
+      dataset_urls: "https://hf.example/datasets/org/dataset-a",
+      space_urls: "https://hf.example/spaces/org/space-a",
+      num_models: 1,
+      num_datasets: 1,
+      num_spaces: 1,
       url: "https://hf.example/papers/1706.03762",
     });
   });
@@ -53,6 +75,7 @@ describe("hf agent-facing paper command", () => {
       "scholar.get",
       "scholar.pdf",
       "scholar.code",
+      "scholar.datasets",
     ]);
   });
 });

package/src/adapters/hf/paper.ts

@@ -1,9 +1,9 @@
 /**
  * @owner   src/adapters/hf/paper.ts
- * @does    Register agent-facing Hugging Face paper detail command.
+ * @does    Register agent-facing Hugging Face paper detail and resource-link command.
  * @needs   Hugging Face public papers API, modern arXiv ids, paper metadata normalization.
- * @feeds   surface coverage ledger, HF daily paper detail workflows, scholarly metadata readers.
- * @breaks  HF papers API shape drift or invalid arXiv id handling can hide paper details.
+ * @feeds   surface coverage ledger, HF daily paper detail workflows, scholarly metadata and resource readers.
+ * @breaks  HF papers API shape drift, resource-link schema drift, or invalid arXiv id handling can hide paper details.
  */
 
 import { cli, Strategy } from "../../registry.js";
@@ -25,6 +25,19 @@ interface HfPaper {
   ai_keywords?: unknown;
   summary?: unknown;
   ai_summary?: unknown;
+  githubRepo?: unknown;
+  githubStars?: unknown;
+  projectPage?: unknown;
+  linkedDatasets?: unknown;
+  linkedModels?: unknown;
+  linkedSpaces?: unknown;
+  numTotalDatasets?: unknown;
+  numTotalModels?: unknown;
+  numTotalSpaces?: unknown;
+}
+
+interface HfLinkedResource {
+  id?: unknown;
 }
 
 function stringField(value: unknown): string {
@@ -61,12 +74,51 @@ function hfAuthorNames(value: unknown): string {
     .join(", ");
 }
 
+function bareArxivId(value: string): string {
+  return value.replace(/v\d+$/i, "");
+}
+
+function linkedResourceIds(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item: HfLinkedResource | string) =>
+      typeof item === "string" ? item : stringField(item.id),
+    )
+    .map((id) => id.trim())
+    .filter(Boolean);
+}
+
+function linkedResourceUrls(
+  value: unknown,
+  kind: "dataset" | "model" | "space",
+  endpoint: string,
+): string[] {
+  const base = hfEndpoint(endpoint);
+  return linkedResourceIds(value).map((id) => {
+    if (kind === "dataset") return `${base}/datasets/${id}`;
+    if (kind === "space") return `${base}/spaces/${id}`;
+    return `${base}/${id}`;
+  });
+}
+
+function csv(values: string[]): string {
+  return values.join(", ");
+}
+
 export function mapHfPaperRow(
   paper: HfPaper,
   endpoint = HF_DEFAULT_ENDPOINT,
 ): Record<string, unknown> {
   const id = stringField(paper.id);
   if (!id) throw new Error("Hugging Face returned no paper data.");
+  const sourceUrl = `${hfEndpoint(endpoint)}/papers/${id}`;
+  const datasetUrls = linkedResourceUrls(
+    paper.linkedDatasets,
+    "dataset",
+    endpoint,
+  );
+  const modelUrls = linkedResourceUrls(paper.linkedModels, "model", endpoint);
+  const spaceUrls = linkedResourceUrls(paper.linkedSpaces, "space", endpoint);
   return {
     id,
     title: stringField(paper.title),
@@ -78,7 +130,20 @@ export function mapHfPaperRow(
       : "",
     summary: stringField(paper.summary),
     aiSummary: stringField(paper.ai_summary),
-    url: `${hfEndpoint(endpoint)}/papers/${id}`,
+    arxiv_id: bareArxivId(id),
+    pdf_url: `https://arxiv.org/pdf/${id}`,
+    source_url: sourceUrl,
+    code_url: stringField(paper.githubRepo),
+    github_stars: numberOrNull(paper.githubStars),
+    project_url: stringField(paper.projectPage),
+    dataset_url: datasetUrls[0] ?? "",
+    model_urls: csv(modelUrls),
+    dataset_urls: csv(datasetUrls),
+    space_urls: csv(spaceUrls),
+    num_models: numberOrNull(paper.numTotalModels),
+    num_datasets: numberOrNull(paper.numTotalDatasets),
+    num_spaces: numberOrNull(paper.numTotalSpaces),
+    url: sourceUrl,
   };
 }
 
@@ -129,9 +194,28 @@ cli({
     "aiKeywords",
     "summary",
     "aiSummary",
+    "arxiv_id",
+    "pdf_url",
+    "source_url",
+    "code_url",
+    "github_stars",
+    "project_url",
+    "dataset_url",
+    "model_urls",
+    "dataset_urls",
+    "space_urls",
+    "num_models",
+    "num_datasets",
+    "num_spaces",
     "url",
   ],
-  capabilities: ["http.fetch", "scholar.get", "scholar.pdf", "scholar.code"],
+  capabilities: [
+    "http.fetch",
+    "scholar.get",
+    "scholar.pdf",
+    "scholar.code",
+    "scholar.datasets",
+  ],
   func: async (_page, kwargs) => {
     const id = requireHfPaperId(kwargs.id);
     return [mapHfPaperRow(await fetchHfPaper(id), hfEndpoint())];

package/src/adapters/hf/top.yaml

@@ -26,13 +26,45 @@ pipeline:
       title: "${{ (item.title || '').length > 60 ? (item.title || '').slice(0, 57) + '...' : (item.title || '') }}"
       upvotes: "${{ item.paper ? item.paper.upvotes : 0 }}"
       authors: "${{ (() => { const a = item.paper && item.paper.authors ? item.paper.authors : []; const n = a.map(x => x.name); return n.length <= 3 ? n.join(', ') : n.slice(0, 3).join(', ') + ' et al.'; })() }}"
+      source_url: "${{ item.paper && item.paper.id ? 'https://huggingface.co/papers/' + item.paper.id : '' }}"
+      pdf_url: "${{ item.paper && item.paper.id ? 'https://arxiv.org/pdf/' + item.paper.id : '' }}"
+      code_url: "${{ item.paper && item.paper.githubRepo ? item.paper.githubRepo : '' }}"
+      github_stars: "${{ item.paper && item.paper.githubStars ? item.paper.githubStars : '' }}"
+      project_url: "${{ item.paper && item.paper.projectPage ? item.paper.projectPage : '' }}"
+      dataset_url: "${{ item.paper && item.paper.linkedDatasets && item.paper.linkedDatasets[0] ? 'https://huggingface.co/datasets/' + item.paper.linkedDatasets[0].id : '' }}"
+      model_urls: "${{ item.paper && item.paper.linkedModels ? item.paper.linkedModels.map(x => 'https://huggingface.co/' + x.id).join(', ') : '' }}"
+      dataset_urls: "${{ item.paper && item.paper.linkedDatasets ? item.paper.linkedDatasets.map(x => 'https://huggingface.co/datasets/' + x.id).join(', ') : '' }}"
+      space_urls: "${{ item.paper && item.paper.linkedSpaces ? item.paper.linkedSpaces.map(x => 'https://huggingface.co/spaces/' + x.id).join(', ') : '' }}"
+      num_models: "${{ item.paper && item.paper.numTotalModels !== null && item.paper.numTotalModels !== undefined ? item.paper.numTotalModels : '' }}"
+      num_datasets: "${{ item.paper && item.paper.numTotalDatasets !== null && item.paper.numTotalDatasets !== undefined ? item.paper.numTotalDatasets : '' }}"
+      num_spaces: "${{ item.paper && item.paper.numTotalSpaces !== null && item.paper.numTotalSpaces !== undefined ? item.paper.numTotalSpaces : '' }}"
 
   - limit: ${{ args.limit }}
 
-columns: [rank, id, title, upvotes, authors]
+columns:
+  [
+    rank,
+    id,
+    title,
+    upvotes,
+    authors,
+    source_url,
+    pdf_url,
+    code_url,
+    github_stars,
+    project_url,
+    dataset_url,
+    model_urls,
+    dataset_urls,
+    space_urls,
+    num_models,
+    num_datasets,
+    num_spaces,
+  ]
 
 # schema-v2 metadata — injected by `unicli migrate schema-v2`
-capabilities: ["http.fetch", "scholar.search", "scholar.code"]
+capabilities:
+  ["http.fetch", "scholar.search", "scholar.code", "scholar.datasets"]
 minimum_capability: http.fetch
 trust: public
 confidentiality: public

package/src/adapters/huggingface-papers/daily.yaml

@@ -6,22 +6,56 @@ domain: huggingface.co
 strategy: public
 args:
   limit:
+    type: int
     required: false
     default: 20
 pipeline:
   - fetch:
       url: "https://huggingface.co/api/daily_papers"
   - map:
+      id: "${{ item.paper && item.paper.id ? item.paper.id : '' }}"
       title: "${{ item.paper.title }}"
-      authors: "${{ item.paper.authors[0].name }}"
+      authors: "${{ item.paper && item.paper.authors ? item.paper.authors.map(x => x.name).filter(Boolean).join(', ') : '' }}"
       upvotes: "${{ item.paper.upvotes }}"
       url: "${{ 'https://huggingface.co/papers/' + item.paper.id }}"
+      source_url: "${{ item.paper && item.paper.id ? 'https://huggingface.co/papers/' + item.paper.id : '' }}"
+      pdf_url: "${{ item.paper && item.paper.id ? 'https://arxiv.org/pdf/' + item.paper.id : '' }}"
+      code_url: "${{ item.paper && item.paper.githubRepo ? item.paper.githubRepo : '' }}"
+      github_stars: "${{ item.paper && item.paper.githubStars ? item.paper.githubStars : '' }}"
+      project_url: "${{ item.paper && item.paper.projectPage ? item.paper.projectPage : '' }}"
+      dataset_url: "${{ item.paper && item.paper.linkedDatasets && item.paper.linkedDatasets[0] ? 'https://huggingface.co/datasets/' + item.paper.linkedDatasets[0].id : '' }}"
+      model_urls: "${{ item.paper && item.paper.linkedModels ? item.paper.linkedModels.map(x => 'https://huggingface.co/' + x.id).join(', ') : '' }}"
+      dataset_urls: "${{ item.paper && item.paper.linkedDatasets ? item.paper.linkedDatasets.map(x => 'https://huggingface.co/datasets/' + x.id).join(', ') : '' }}"
+      space_urls: "${{ item.paper && item.paper.linkedSpaces ? item.paper.linkedSpaces.map(x => 'https://huggingface.co/spaces/' + x.id).join(', ') : '' }}"
+      num_models: "${{ item.paper && item.paper.numTotalModels !== null && item.paper.numTotalModels !== undefined ? item.paper.numTotalModels : '' }}"
+      num_datasets: "${{ item.paper && item.paper.numTotalDatasets !== null && item.paper.numTotalDatasets !== undefined ? item.paper.numTotalDatasets : '' }}"
+      num_spaces: "${{ item.paper && item.paper.numTotalSpaces !== null && item.paper.numTotalSpaces !== undefined ? item.paper.numTotalSpaces : '' }}"
       date: "${{ item.publishedAt }}"
   - limit: "${{ args.limit | default(20) }}"
-columns: [title, authors, upvotes, url]
+columns:
+  [
+    id,
+    title,
+    authors,
+    upvotes,
+    url,
+    source_url,
+    pdf_url,
+    code_url,
+    github_stars,
+    project_url,
+    dataset_url,
+    model_urls,
+    dataset_urls,
+    space_urls,
+    num_models,
+    num_datasets,
+    num_spaces,
+  ]
 
 # schema-v2 metadata — injected by `unicli migrate schema-v2`
-capabilities: ["http.fetch", "scholar.search", "scholar.code"]
+capabilities:
+  ["http.fetch", "scholar.search", "scholar.code", "scholar.datasets"]
 minimum_capability: http.fetch
 trust: public
 confidentiality: public