@jackwener/opencli 1.7.11 → 1.7.13

package/clis/packagist/search.js

@@ -0,0 +1,43 @@
+// packagist search — search Packagist's PHP / Composer package registry.
+//
+// Hits `https://packagist.org/search.json?q=…&per_page=…`. Returns the
+// agent-useful projection: vendor/package (round-trips into `packagist
+// package`), description, lifetime download count, GitHub-stars-style favers,
+// repository URL.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { PACKAGIST_BASE, packagistFetch, requireBoundedInt, requireString } from './utils.js';
+
+cli({
+    site: 'packagist',
+    name: 'search',
+    access: 'read',
+    description: 'Search Packagist (PHP / Composer) packages by keyword',
+    domain: 'packagist.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword (e.g. "symfony", "laravel http")' },
+        { name: 'limit', type: 'int', default: 30, help: 'Max packages (1-100, single Packagist page)' },
+    ],
+    columns: ['rank', 'package', 'description', 'downloads', 'favers', 'repository', 'url'],
+    func: async (args) => {
+        const query = requireString(args.query, 'query');
+        const limit = requireBoundedInt(args.limit, 30, 100);
+        const url = `${PACKAGIST_BASE}/search.json?q=${encodeURIComponent(query)}&per_page=${limit}`;
+        const body = await packagistFetch(url, 'packagist search');
+        const list = Array.isArray(body?.results) ? body.results : [];
+        if (!list.length) {
+            throw new EmptyResultError('packagist search', `No Packagist packages matched "${query}".`);
+        }
+        return list.slice(0, limit).map((row, i) => ({
+            rank: i + 1,
+            package: String(row.name ?? '').trim(),
+            description: String(row.description ?? '').trim(),
+            downloads: row.downloads != null ? Number(row.downloads) : null,
+            favers: row.favers != null ? Number(row.favers) : null,
+            repository: String(row.repository ?? '').trim(),
+            url: String(row.url ?? '').trim(),
+        }));
+    },
+});

package/clis/packagist/utils.js

@@ -0,0 +1,113 @@
+// Shared helpers for the Packagist (PHP / Composer) adapters.
+//
+// Hits the public, unauthenticated `packagist.org` JSON endpoints. Composer's
+// canonical package registry. Package names are `<vendor>/<package>`,
+// lowercase letters / digits / `_-.`, with each segment 1-100 chars.
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const PACKAGIST_BASE = 'https://packagist.org';
+const UA = 'opencli-packagist-adapter (+https://github.com/jackwener/opencli)';
+
+// Each segment of a Composer package name (`vendor` and `package`).
+const SEGMENT = /^[a-z0-9]([_.-]?[a-z0-9]+)*$/;
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`packagist ${label} cannot be empty`);
+    return s;
+}
+
+export function requireBoundedInt(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`packagist ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`packagist ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export function requirePackageName(value) {
+    const raw = String(value ?? '').trim().toLowerCase();
+    if (!raw) {
+        throw new ArgumentError('packagist package name is required (e.g. "symfony/console", "monolog/monolog")');
+    }
+    const slash = raw.indexOf('/');
+    if (slash <= 0 || slash === raw.length - 1) {
+        throw new ArgumentError(
+            `packagist package "${value}" must be "<vendor>/<package>"`,
+            'Both segments are required (Composer convention).',
+        );
+    }
+    const vendor = raw.slice(0, slash);
+    const pkg = raw.slice(slash + 1);
+    if (vendor.length > 100 || pkg.length > 100 || !SEGMENT.test(vendor) || !SEGMENT.test(pkg)) {
+        throw new ArgumentError(
+            `packagist package "${value}" is not a valid Composer name`,
+            'Use lowercase letters / digits / "_-.", segments separated by single "_-." chars (max 100 chars each).',
+        );
+    }
+    return { vendor, package: pkg, full: `${vendor}/${pkg}` };
+}
+
+export async function packagistFetch(url, label) {
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that packagist.org is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `Packagist returned 404 for ${url}.`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(
+            `${label} returned HTTP 429 (rate limited)`,
+            'Packagist throttles bursts; wait a few seconds and retry.',
+        );
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`${label} returned HTTP ${resp.status}`);
+    }
+    let body;
+    try {
+        body = await resp.json();
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} returned malformed JSON: ${err?.message ?? err}`);
+    }
+    return body;
+}
+
+/** Trim "2026-05-05T17:32:01+00:00" → "2026-05-05T17:32:01Z" so timestamps are uniform. */
+export function trimDate(value) {
+    const s = String(value ?? '').trim();
+    if (!s) return null;
+    const noFrac = s.replace(/\.\d+/, '');
+    return noFrac.replace(/(?:[+-]\d{2}:?\d{2}|Z)?$/, 'Z');
+}
+
+/**
+ * Pick the newest stable (non-dev / non-prerelease) version key from a
+ * Packagist `versions` map. Packagist returns keys ordered newest-first.
+ * Falls back to the first key if no stable found.
+ */
+export function pickStableVersion(versions) {
+    if (!versions || typeof versions !== 'object') return null;
+    const keys = Object.keys(versions);
+    if (!keys.length) return null;
+    const PRE = /(?:^|[._\-+])(?:dev|alpha|beta|rc|pre|nightly)(?:[._\-+\d]|$)/i;
+    const DEV_SUFFIX = /\.x-dev$|-dev$/i;
+    for (const k of keys) {
+        if (DEV_SUFFIX.test(k)) continue;
+        if (PRE.test(k)) continue;
+        return k;
+    }
+    return keys[0];
+}

package/clis/paperreview/feedback.js

@@ -4,17 +4,18 @@ import { PAPERREVIEW_DOMAIN, ensureSuccess, parseYesNo, requestJson, summarizeFe
 cli({
     site: 'paperreview',
     name: 'feedback',
+    access: 'write',
     description: 'Submit feedback for a paperreview.ai review token',
     domain: PAPERREVIEW_DOMAIN,
     strategy: Strategy.PUBLIC,
     browser: false,
-    timeoutSeconds: 30,
     args: [
         { name: 'token', positional: true, required: true, help: 'Review token returned by paperreview.ai' },
         { name: 'helpfulness', required: true, type: 'int', help: 'Helpfulness score from 1 to 5' },
         { name: 'critical-error', required: true, choices: ['yes', 'no'], help: 'Whether the review contains a critical error' },
         { name: 'actionable-suggestions', required: true, choices: ['yes', 'no'], help: 'Whether the review contains actionable suggestions' },
         { name: 'additional-comments', help: 'Optional free-text feedback' },
+        { name: 'timeout', type: 'int', required: false, default: 30, help: 'Max seconds for the overall command (default: 30)' },
     ],
     columns: ['status', 'token', 'helpfulness', 'critical_error', 'actionable_suggestions', 'message'],
     func: async (kwargs) => {

package/clis/paperreview/review.js

@@ -4,13 +4,14 @@ import { PAPERREVIEW_DOMAIN, buildReviewUrl, ensureSuccess, requestJson, summari
 cli({
     site: 'paperreview',
     name: 'review',
+    access: 'read',
     description: 'Fetch a paperreview.ai review by token',
     domain: PAPERREVIEW_DOMAIN,
     strategy: Strategy.PUBLIC,
     browser: false,
-    timeoutSeconds: 30,
     args: [
         { name: 'token', positional: true, required: true, help: 'Review token returned by paperreview.ai' },
+        { name: 'timeout', type: 'int', required: false, default: 30, help: 'Max seconds for the overall command (default: 30)' },
     ],
     columns: ['status', 'title', 'venue', 'numerical_score', 'has_feedback', 'review_url'],
     func: async (kwargs) => {

package/clis/paperreview/submit.js

@@ -4,17 +4,18 @@ import { PAPERREVIEW_DOMAIN, ensureApiSuccess, ensureSuccess, normalizeVenue, re
 cli({
     site: 'paperreview',
     name: 'submit',
+    access: 'write',
     description: 'Submit a PDF to paperreview.ai for review',
     domain: PAPERREVIEW_DOMAIN,
     strategy: Strategy.PUBLIC,
     browser: false,
-    timeoutSeconds: 120,
     args: [
         { name: 'pdf', positional: true, required: true, help: 'Path to the paper PDF' },
         { name: 'email', required: true, help: 'Email address for the submission' },
         { name: 'venue', help: 'Optional target venue such as ICLR or NeurIPS' },
         { name: 'dry-run', type: 'bool', default: false, help: 'Validate the input and stop before remote submission' },
         { name: 'prepare-only', type: 'bool', default: false, help: 'Request an upload slot but stop before uploading the PDF' },
+        { name: 'timeout', type: 'int', required: false, default: 120, help: 'Max seconds for the overall command (default: 120)' },
     ],
     columns: ['status', 'file', 'email', 'venue', 'token', 'review_url', 'message'],
     footerExtra: (kwargs) => {

package/clis/pixiv/detail.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'pixiv',
     name: 'detail',
+    access: 'read',
     description: 'View illustration details (tags, stats, URLs)',
     domain: 'www.pixiv.net',
     strategy: Strategy.COOKIE,

package/clis/pixiv/download.js

@@ -14,6 +14,7 @@ import { pixivFetch } from './utils.js';
 cli({
     site: 'pixiv',
     name: 'download',
+    access: 'read',
     description: 'Download illustration images from Pixiv',
     domain: 'www.pixiv.net',
     strategy: Strategy.COOKIE,

package/clis/pixiv/download.test.js

@@ -1,7 +1,7 @@
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
-import { createPageMock } from './test-utils.js';
+import { createPageMock } from '../test-utils.js';
 // Mock download dependencies before importing the adapter
 const { mockHttpDownload, mockMkdirSync } = vi.hoisted(() => ({
     mockHttpDownload: vi.fn(),

package/clis/pixiv/illusts.js

@@ -11,6 +11,7 @@ import { pixivFetch, BATCH_SIZE } from './utils.js';
 cli({
     site: 'pixiv',
     name: 'illusts',
+    access: 'read',
     description: "List a Pixiv artist's illustrations",
     domain: 'www.pixiv.net',
     strategy: Strategy.COOKIE,
@@ -18,7 +19,7 @@ cli({
         { name: 'user-id', positional: true, required: true, help: 'Pixiv user ID' },
         { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
     ],
-    columns: ['rank', 'title', 'illust_id', 'pages', 'bookmarks', 'tags', 'created'],
+    columns: ['rank', 'title', 'illust_id', 'pages', 'bookmarks', 'tags', 'created', 'url'],
     func: async (page, kwargs) => {
         const userId = String(kwargs['user-id'] ?? '');
         const limit = Number(kwargs.limit) || 20;

package/clis/pixiv/illusts.test.js

@@ -1,7 +1,7 @@
 import { beforeAll, describe, expect, it } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
-import { createPageMock } from './test-utils.js';
+import { createPageMock } from '../test-utils.js';
 import './illusts.js';
 let cmd;
 beforeAll(() => {

package/clis/pixiv/ranking.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'pixiv',
     name: 'ranking',
+    access: 'read',
     description: 'Pixiv illustration rankings (daily/weekly/monthly)',
     domain: 'www.pixiv.net',
     strategy: Strategy.COOKIE,
@@ -26,7 +27,7 @@ cli({
         { name: 'page', type: 'int', default: 1, help: 'Page number' },
         { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
     ],
-    columns: ['rank', 'title', 'author', 'illust_id', 'pages', 'bookmarks'],
+    columns: ['rank', 'title', 'author', 'user_id', 'illust_id', 'pages', 'bookmarks', 'url'],
     pipeline: [
         { navigate: 'https://www.pixiv.net' },
         { evaluate: `(async () => {

package/clis/pixiv/search.js

@@ -8,6 +8,7 @@ import { pixivFetch } from './utils.js';
 cli({
     site: 'pixiv',
     name: 'search',
+    access: 'read',
     description: 'Search Pixiv illustrations by keyword',
     domain: 'www.pixiv.net',
     strategy: Strategy.COOKIE,
@@ -18,7 +19,7 @@ cli({
         { name: 'mode', type: 'str', default: 'all', help: 'Search mode', choices: ['all', 'safe', 'r18'] },
         { name: 'page', type: 'int', default: 1, help: 'Page number' },
     ],
-    columns: ['rank', 'title', 'author', 'illust_id', 'pages', 'bookmarks', 'tags'],
+    columns: ['rank', 'title', 'author', 'user_id', 'illust_id', 'pages', 'bookmarks', 'tags', 'url'],
     func: async (page, kwargs) => {
         const { query, limit = 20, order = 'date_d', mode = 'all', page: pageNum = 1 } = kwargs;
         const encoded = encodeURIComponent(query);

package/clis/pixiv/search.test.js

@@ -1,7 +1,7 @@
 import { beforeAll, describe, expect, it } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
-import { createPageMock } from './test-utils.js';
+import { createPageMock } from '../test-utils.js';
 import './search.js';
 let cmd;
 beforeAll(() => {

package/clis/pixiv/user.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'pixiv',
     name: 'user',
+    access: 'read',
     description: 'View Pixiv artist profile',
     domain: 'www.pixiv.net',
     strategy: Strategy.COOKIE,
@@ -18,6 +19,7 @@ cli({
         'manga',
         'novels',
         'comment',
+        'url',
     ],
     pipeline: [
         { navigate: 'https://www.pixiv.net' },

package/clis/powerchina/search.js

@@ -159,6 +159,7 @@ async function searchRowsFromApi(query, limit) {
 cli({
   site: 'powerchina',
   name: 'search',
+    access: 'read',
   description: '搜索中国电建阳光采购公告',
   domain: 'bid.powerchina.cn',
   strategy: Strategy.COOKIE,

package/clis/producthunt/browse.js

@@ -10,6 +10,7 @@ import { PRODUCTHUNT_CATEGORY_SLUGS } from './utils.js';
 cli({
     site: 'producthunt',
     name: 'browse',
+    access: 'read',
     description: 'Best products in a Product Hunt category',
     domain: 'www.producthunt.com',
     strategy: Strategy.INTERCEPT,

package/clis/producthunt/hot.js

@@ -9,6 +9,7 @@ import { pickVoteCount } from './utils.js';
 cli({
     site: 'producthunt',
     name: 'hot',
+    access: 'read',
     description: "Today's top Product Hunt launches with vote counts",
     domain: 'www.producthunt.com',
     strategy: Strategy.INTERCEPT,

package/clis/producthunt/posts.js

@@ -6,6 +6,7 @@ import { fetchFeed, PRODUCTHUNT_CATEGORY_SLUGS } from './utils.js';
 cli({
     site: 'producthunt',
     name: 'posts',
+    access: 'read',
     description: 'Latest Product Hunt launches (optional category filter)',
     domain: 'www.producthunt.com',
     strategy: Strategy.PUBLIC,

package/clis/producthunt/today.js

@@ -9,6 +9,7 @@ import { fetchFeed } from './utils.js';
 cli({
     site: 'producthunt',
     name: 'today',
+    access: 'read',
     description: "Today's Product Hunt launches (most recent day in feed)",
     domain: 'www.producthunt.com',
     strategy: Strategy.PUBLIC,

package/clis/pubmed/article.js

@@ -0,0 +1,50 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { eutilsFetch, parseArticleXml, requirePmid, truncateText } from './utils.js';
+
+cli({
+    site: 'pubmed',
+    name: 'article',
+    aliases: ['paper', 'read'],
+    access: 'read',
+    description: 'Get detailed information for a PubMed article by PMID',
+    domain: 'pubmed.ncbi.nlm.nih.gov',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'pmid', positional: true, required: true, help: 'PubMed ID, e.g. 37780221' },
+        { name: 'full-abstract', type: 'boolean', default: false, help: 'Do not truncate the abstract in table output' },
+    ],
+    columns: ['field', 'value'],
+    func: async (args) => {
+        const pmid = requirePmid(args.pmid);
+        const xml = await eutilsFetch('efetch', {
+            id: pmid,
+            rettype: 'abstract',
+        }, { retmode: 'xml', label: 'pubmed article' });
+        const article = parseArticleXml(xml, pmid);
+        if (!article) {
+            throw new EmptyResultError('pubmed article', `No article found for PMID ${pmid}.`);
+        }
+        if (!article.title) {
+            throw new CommandExecutionError(`pubmed article ${pmid} did not include a title`, 'PubMed EFetch response shape may have changed.');
+        }
+        const abstract = args['full-abstract'] ? article.abstract : truncateText(article.abstract, 500);
+        return [
+            { field: 'PMID', value: article.pmid },
+            { field: 'Title', value: article.title },
+            { field: 'Authors', value: article.authors.join(', ') },
+            { field: 'Journal', value: article.journal },
+            { field: 'Year', value: article.year },
+            { field: 'Date', value: article.date },
+            { field: 'Article Type', value: article.article_type },
+            { field: 'Language', value: article.language },
+            { field: 'DOI', value: article.doi || null },
+            { field: 'PMC ID', value: article.pmc || null },
+            { field: 'MeSH Terms', value: article.mesh_terms || null },
+            { field: 'Keywords', value: article.keywords || null },
+            { field: 'Abstract', value: abstract || null },
+            { field: 'URL', value: article.url },
+        ];
+    },
+});

package/clis/pubmed/author.js

@@ -0,0 +1,64 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    LINK_COLUMNS,
+    eutilsFetch,
+    fetchSummaryRows,
+    requireBoundedInt,
+    requireChoice,
+    requireText,
+    requireYear,
+} from './utils.js';
+
+cli({
+    site: 'pubmed',
+    name: 'author',
+    access: 'read',
+    description: 'Search PubMed articles by author name and optional affiliation',
+    domain: 'pubmed.ncbi.nlm.nih.gov',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'name', positional: true, required: true, help: 'Author name, e.g. "Smith J"' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results (1-100)' },
+        { name: 'affiliation', help: 'Filter by author affiliation' },
+        { name: 'position', default: 'any', choices: ['any', 'first', 'last'], help: 'Author position: any, first, or last' },
+        { name: 'year-from', type: 'int', help: 'Filter publication year from' },
+        { name: 'year-to', type: 'int', help: 'Filter publication year to' },
+        { name: 'sort', default: 'date', choices: ['date', 'relevance'], help: 'Sort by date or relevance' },
+    ],
+    columns: LINK_COLUMNS,
+    func: async (args) => {
+        const name = requireText(args.name, 'author');
+        const limit = requireBoundedInt(args.limit, 20, 100);
+        const position = requireChoice(args.position, ['any', 'first', 'last'], 'position', 'any');
+        const sort = requireChoice(args.sort, ['date', 'relevance'], 'sort', 'date');
+        const yearFrom = requireYear(args['year-from'], 'year-from');
+        const yearTo = requireYear(args['year-to'], 'year-to');
+        const authorTag = position === 'first' ? '1au' : position === 'last' ? 'lastau' : 'au';
+        const terms = [`${name}[${authorTag}]`];
+        if (args.affiliation) terms.push(`${requireText(args.affiliation, 'affiliation')}[ad]`);
+        if (yearFrom || yearTo) {
+            const from = yearFrom || 1800;
+            const to = yearTo || new Date().getFullYear();
+            if (from > to) {
+                throw new ArgumentError('pubmed year-from must be <= year-to');
+            }
+            terms.push(`${from}:${to}[PDAT]`);
+        }
+        const esearch = await eutilsFetch('esearch', {
+            term: terms.join(' AND '),
+            retmax: limit,
+            usehistory: 'y',
+            sort: sort === 'date' ? 'pub_date' : '',
+        }, { label: 'pubmed author' });
+        const pmids = esearch?.esearchresult?.idlist;
+        if (!Array.isArray(pmids)) {
+            throw new CommandExecutionError('pubmed author did not return an id list', 'PubMed ESearch response shape may have changed.');
+        }
+        if (pmids.length === 0) {
+            throw new EmptyResultError('pubmed author', `No articles found for author "${name}".`);
+        }
+        return fetchSummaryRows(pmids, 'pubmed author summary');
+    },
+});

package/clis/pubmed/citations.js

@@ -0,0 +1,36 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { LINK_COLUMNS, eutilsFetch, fetchSummaryRows, requireBoundedInt, requireChoice, requirePmid } from './utils.js';
+
+cli({
+    site: 'pubmed',
+    name: 'citations',
+    access: 'read',
+    description: 'Get PubMed citation relationships for an article',
+    domain: 'pubmed.ncbi.nlm.nih.gov',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'pmid', positional: true, required: true, help: 'PubMed ID, e.g. 37780221' },
+        { name: 'direction', default: 'citedby', choices: ['citedby', 'references'], help: 'citedby or references' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results (1-100)' },
+    ],
+    columns: LINK_COLUMNS,
+    func: async (args) => {
+        const pmid = requirePmid(args.pmid);
+        const direction = requireChoice(args.direction, ['citedby', 'references'], 'direction', 'citedby');
+        const limit = requireBoundedInt(args.limit, 20, 100);
+        const linkname = direction === 'citedby' ? 'pubmed_pubmed_citedin' : 'pubmed_pubmed_refs';
+        const result = await eutilsFetch('elink', {
+            id: pmid,
+            dbfrom: 'pubmed',
+            cmd: 'neighbor',
+            linkname,
+        }, { label: 'pubmed citations' });
+        const links = result?.linksets?.[0]?.linksetdbs?.[0]?.links;
+        if (!Array.isArray(links) || links.length === 0) {
+            throw new EmptyResultError('pubmed citations', `No ${direction} links found for PMID ${pmid}.`);
+        }
+        return fetchSummaryRows(links.slice(0, limit).map(String), 'pubmed citations summary');
+    },
+});