@yangfei_93sky/biocli 0.2.0

package/dist/clis/geo/dataset.js

@@ -0,0 +1,55 @@
+/**
+ * geo/dataset — Get GEO dataset details by accession.
+ *
+ * Searches by accession (GSE, GDS, GPL, GSM) in the gds database,
+ * then retrieves the full summary via esummary (JSON).
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildEutilsUrl } from '../_shared/eutils.js';
+import { truncate } from '../_shared/common.js';
+cli({
+    site: 'geo',
+    name: 'dataset',
+    description: 'Get GEO dataset details by accession',
+    database: 'gds',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'accession', positional: true, required: true, help: 'GEO accession (e.g. GSE12345, GDS1234)' },
+    ],
+    columns: ['accession', 'title', 'organism', 'type', 'platform', 'samples', 'summary', 'date'],
+    func: async (ctx, args) => {
+        const acc = String(args.accession).toUpperCase();
+        // Step 1: esearch by accession
+        const searchResult = await ctx.fetchJson(buildEutilsUrl('esearch.fcgi', {
+            db: 'gds',
+            term: `${acc}[Accession]`,
+            retmode: 'json',
+        }));
+        const result = searchResult;
+        const esearchResult = result?.esearchresult;
+        const ids = esearchResult?.idlist ?? [];
+        if (!ids.length) {
+            throw new CliError('NOT_FOUND', `GEO entry ${acc} not found`, 'Check that the accession is correct (e.g. GSE12345, GDS1234)');
+        }
+        // Step 2: esummary for full details
+        const summaryResult = await ctx.fetchJson(buildEutilsUrl('esummary.fcgi', {
+            db: 'gds',
+            id: ids[0],
+            retmode: 'json',
+        }));
+        const summary = summaryResult;
+        const resultObj = summary?.result;
+        const item = (resultObj?.[ids[0]] ?? {});
+        return [{
+                accession: String(item.accession ?? acc),
+                title: String(item.title ?? ''),
+                organism: String(item.taxon ?? ''),
+                type: String(item.entrytype ?? ''),
+                platform: String(item.gpl ?? ''),
+                samples: Number(item.n_samples ?? 0),
+                summary: truncate(String(item.summary ?? ''), 300),
+                date: String(item.pdat ?? ''),
+            }];
+    },
+});

package/dist/clis/geo/download.d.ts

@@ -0,0 +1,17 @@
+/**
+ * geo/download — Download GEO supplementary files.
+ *
+ * GEO stores supplementary files at a predictable HTTPS URL:
+ *   https://ftp.ncbi.nlm.nih.gov/geo/series/GSEnnn/GSExxxxx/suppl/
+ *
+ * This command:
+ *   1. Lists available supplementary files for a GSE accession
+ *   2. Downloads them to a specified directory (or current dir)
+ */
+/** Build the GEO FTP-over-HTTPS URL for supplementary files. */
+export declare function buildGeoSupplUrl(accession: string): string;
+/** Parse file list from NCBI FTP directory listing (HTML). */
+export declare function parseFileList(html: string): {
+    name: string;
+    size: string;
+}[];

package/dist/clis/geo/download.js

@@ -0,0 +1,115 @@
+/**
+ * geo/download — Download GEO supplementary files.
+ *
+ * GEO stores supplementary files at a predictable HTTPS URL:
+ *   https://ftp.ncbi.nlm.nih.gov/geo/series/GSEnnn/GSExxxxx/suppl/
+ *
+ * This command:
+ *   1. Lists available supplementary files for a GSE accession
+ *   2. Downloads them to a specified directory (or current dir)
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { mkdirSync, existsSync, createWriteStream } from 'node:fs';
+import { join } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { Readable } from 'node:stream';
+import { withMeta } from '../../types.js';
+/** Build the GEO FTP-over-HTTPS URL for supplementary files. */
+export function buildGeoSupplUrl(accession) {
+    // GSE12345 → series/GSE12nnn/GSE12345/suppl/
+    const prefix = accession.slice(0, -3) + 'nnn';
+    return `https://ftp.ncbi.nlm.nih.gov/geo/series/${prefix}/${accession}/suppl/`;
+}
+/** Parse file list from NCBI FTP directory listing (HTML). */
+export function parseFileList(html) {
+    const files = [];
+    // NCBI FTP HTML listings have <a href="filename">filename</a> followed by size info
+    const linkRegex = /<a\s+href="([^"]+)">[^<]+<\/a>\s+[\d-]+\s+[\d:]+\s+([\d.]+[KMG]?)/gi;
+    let match;
+    while ((match = linkRegex.exec(html)) !== null) {
+        const name = match[1];
+        // Skip parent directory and non-file links
+        if (name === '../' || name.endsWith('/') || name.startsWith('?'))
+            continue;
+        files.push({ name, size: match[2] });
+    }
+    return files;
+}
+cli({
+    site: 'geo',
+    name: 'download',
+    description: 'Download GEO supplementary files (expression matrices, etc.)',
+    database: 'gds',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'accession', positional: true, required: true, help: 'GEO Series accession (e.g. GSE12345)' },
+        { name: 'outdir', default: '.', help: 'Output directory (default: current directory)' },
+        { name: 'list-only', type: 'boolean', default: false, help: 'Only list available files, do not download' },
+        { name: 'dry-run', type: 'boolean', default: false, help: 'Same as --list-only: show files without downloading' },
+        { name: 'pattern', help: 'Filter files by pattern (e.g. "counts", "matrix", "tar.gz")' },
+    ],
+    columns: ['file', 'size', 'status'],
+    func: async (ctx, args) => {
+        const accession = String(args.accession).toUpperCase().trim();
+        if (!/^GSE\d+$/.test(accession)) {
+            throw new CliError('ARGUMENT', `Invalid GEO accession: "${accession}"`, 'Use a GSE accession (e.g. GSE12345)');
+        }
+        const listOnly = Boolean(args['list-only']) || Boolean(args['dry-run']);
+        const outdir = String(args.outdir);
+        const pattern = args.pattern ? String(args.pattern).toLowerCase() : undefined;
+        // Step 1: Get directory listing
+        const supplUrl = buildGeoSupplUrl(accession);
+        let html;
+        try {
+            html = await ctx.fetchText(supplUrl);
+        }
+        catch {
+            throw new CliError('NOT_FOUND', `No supplementary files found for ${accession}`, 'The dataset may not have supplementary files, or the accession may be incorrect');
+        }
+        let files = parseFileList(html);
+        if (!files.length) {
+            throw new CliError('NOT_FOUND', `No downloadable files found at ${supplUrl}`, 'The directory listing may be empty or in an unexpected format');
+        }
+        // Filter by pattern if specified
+        if (pattern) {
+            files = files.filter(f => f.name.toLowerCase().includes(pattern));
+            if (!files.length) {
+                throw new CliError('NOT_FOUND', `No files matching "${pattern}" in ${accession}`, 'Try without --pattern to see all available files');
+            }
+        }
+        // List-only mode
+        if (listOnly) {
+            const rows = files.map(f => ({
+                file: f.name,
+                size: f.size,
+                status: 'available',
+                url: `${supplUrl}${f.name}`,
+            }));
+            return withMeta(rows, { totalCount: rows.length, query: accession });
+        }
+        // Step 2: Download files
+        if (!existsSync(outdir)) {
+            mkdirSync(outdir, { recursive: true });
+        }
+        const rows = [];
+        for (const file of files) {
+            const fileUrl = `${supplUrl}${file.name}`;
+            const destPath = join(outdir, file.name);
+            try {
+                const response = await fetch(fileUrl);
+                if (!response.ok || !response.body) {
+                    rows.push({ file: file.name, size: file.size, status: `failed (HTTP ${response.status})` });
+                    continue;
+                }
+                const writable = createWriteStream(destPath);
+                await pipeline(Readable.fromWeb(response.body), writable);
+                rows.push({ file: file.name, size: file.size, status: `saved → ${destPath}` });
+            }
+            catch (err) {
+                rows.push({ file: file.name, size: file.size, status: `error: ${err instanceof Error ? err.message : String(err)}` });
+            }
+        }
+        return withMeta(rows, { totalCount: rows.length, query: accession });
+    },
+});

package/dist/clis/geo/samples.d.ts

@@ -0,0 +1,7 @@
+/**
+ * geo/samples — List samples in a GEO dataset.
+ *
+ * Searches for GSM (sample) entries associated with a given GEO series
+ * accession, then retrieves sample metadata via esummary (JSON).
+ */
+export {};

package/dist/clis/geo/samples.js

@@ -0,0 +1,57 @@
+/**
+ * geo/samples — List samples in a GEO dataset.
+ *
+ * Searches for GSM (sample) entries associated with a given GEO series
+ * accession, then retrieves sample metadata via esummary (JSON).
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildEutilsUrl } from '../_shared/eutils.js';
+import { clamp } from '../_shared/common.js';
+cli({
+    site: 'geo',
+    name: 'samples',
+    description: 'List samples in a GEO dataset',
+    database: 'gds',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'accession', positional: true, required: true, help: 'GEO series accession (e.g. GSE12345)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results (1-200)' },
+    ],
+    columns: ['accession', 'title', 'organism', 'type'],
+    func: async (ctx, args) => {
+        const acc = String(args.accession).toUpperCase();
+        const limit = clamp(Number(args.limit), 1, 200);
+        // Search for GSM samples within this series
+        const searchResult = await ctx.fetchJson(buildEutilsUrl('esearch.fcgi', {
+            db: 'gds',
+            term: `${acc}[Accession] AND gsm[Entry Type]`,
+            retmax: String(limit),
+            retmode: 'json',
+        }));
+        const result = searchResult;
+        const esearchResult = result?.esearchresult;
+        const ids = esearchResult?.idlist ?? [];
+        if (!ids.length) {
+            throw new CliError('NOT_FOUND', `No samples found for ${acc}`, 'Check that the accession is a valid GEO series (GSE)');
+        }
+        // Get sample details
+        const summaryResult = await ctx.fetchJson(buildEutilsUrl('esummary.fcgi', {
+            db: 'gds',
+            id: ids.join(','),
+            retmode: 'json',
+        }));
+        const summary = summaryResult;
+        const resultObj = summary?.result;
+        const uids = resultObj?.uids ?? [];
+        return uids.map(uid => {
+            const item = (resultObj?.[uid] ?? {});
+            return {
+                accession: String(item.accession ?? `GSM${uid}`),
+                title: String(item.title ?? ''),
+                organism: String(item.taxon ?? ''),
+                type: String(item.entrytype ?? ''),
+            };
+        });
+    },
+});

package/dist/clis/geo/search.d.ts

@@ -0,0 +1,8 @@
+/**
+ * geo/search — Search GEO datasets.
+ *
+ * Uses the two-step esearch + esummary pattern against db=gds:
+ *   1. esearch to retrieve matching GEO DataSet IDs
+ *   2. esummary (JSON) to get dataset metadata
+ */
+export {};

package/dist/clis/geo/search.js

@@ -0,0 +1,66 @@
+/**
+ * geo/search — Search GEO datasets.
+ *
+ * Uses the two-step esearch + esummary pattern against db=gds:
+ *   1. esearch to retrieve matching GEO DataSet IDs
+ *   2. esummary (JSON) to get dataset metadata
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildEutilsUrl } from '../_shared/eutils.js';
+import { clamp } from '../_shared/common.js';
+import { withMeta } from '../../types.js';
+cli({
+    site: 'geo',
+    name: 'search',
+    description: 'Search GEO datasets',
+    database: 'gds',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search query (e.g. "breast cancer RNA-seq")' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max results (1-200)' },
+        { name: 'type', default: 'gse', choices: ['gse', 'gds', 'gpl', 'gsm'], help: 'Entry type filter' },
+    ],
+    columns: ['accession', 'title', 'organism', 'type', 'samples', 'date'],
+    func: async (ctx, args) => {
+        const limit = clamp(Number(args.limit), 1, 200);
+        const typeFilter = String(args.type).toUpperCase();
+        const term = `${args.query} AND ${typeFilter}[Entry Type]`;
+        // Step 1: esearch to get GDS IDs
+        const searchResult = await ctx.fetchJson(buildEutilsUrl('esearch.fcgi', {
+            db: 'gds',
+            term,
+            retmax: String(limit),
+            retmode: 'json',
+        }));
+        const query = String(args.query);
+        const result = searchResult;
+        const esearchResult = result?.esearchresult;
+        const ids = esearchResult?.idlist ?? [];
+        const totalCount = Number(esearchResult?.count ?? 0);
+        if (!ids.length) {
+            throw new CliError('NOT_FOUND', 'No GEO entries found', 'Try different search terms or a different entry type');
+        }
+        // Step 2: esummary to get dataset details
+        const summaryResult = await ctx.fetchJson(buildEutilsUrl('esummary.fcgi', {
+            db: 'gds',
+            id: ids.join(','),
+            retmode: 'json',
+        }));
+        const summary = summaryResult;
+        const resultObj = summary?.result;
+        const uids = resultObj?.uids ?? [];
+        const rows = uids.map(uid => {
+            const item = (resultObj?.[uid] ?? {});
+            return {
+                accession: String(item.accession ?? `GDS${uid}`),
+                title: String(item.title ?? ''),
+                organism: String(item.taxon ?? ''),
+                type: String(item.entrytype ?? ''),
+                samples: Number(item.n_samples ?? 0),
+                date: String(item.pdat ?? ''),
+            };
+        });
+        return withMeta(rows, { totalCount, query });
+    },
+});

package/dist/clis/kegg/convert.d.ts

@@ -0,0 +1,7 @@
+/**
+ * kegg/convert — Convert IDs between KEGG and other databases.
+ *
+ * Uses KEGG REST /conv endpoint for ID mapping between
+ * KEGG gene IDs and NCBI Gene IDs, UniProt accessions, etc.
+ */
+export {};

package/dist/clis/kegg/convert.js

@@ -0,0 +1,37 @@
+/**
+ * kegg/convert — Convert IDs between KEGG and other databases.
+ *
+ * Uses KEGG REST /conv endpoint for ID mapping between
+ * KEGG gene IDs and NCBI Gene IDs, UniProt accessions, etc.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildKeggUrl, parseKeggTsv } from '../../databases/kegg.js';
+import { withMeta } from '../../types.js';
+cli({
+    site: 'kegg',
+    name: 'convert',
+    description: 'Convert IDs between KEGG and external databases',
+    database: 'kegg',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'ID to convert (e.g. hsa:7157, ncbi-geneid:7157)' },
+        { name: 'to', default: 'ncbi-geneid', choices: ['ncbi-geneid', 'ncbi-proteinid', 'uniprot'], help: 'Target database' },
+    ],
+    columns: ['source', 'target'],
+    func: async (ctx, args) => {
+        const id = String(args.id).trim();
+        const target = String(args.to);
+        // Determine direction: /conv/target/source
+        const text = await ctx.fetchText(buildKeggUrl(`/conv/${target}/${id}`));
+        if (!text.trim()) {
+            throw new CliError('NOT_FOUND', `No conversion found for ${id} → ${target}`, 'Check the ID format');
+        }
+        const parsed = parseKeggTsv(text);
+        const rows = parsed.map(p => ({
+            source: p.key,
+            target: p.value,
+        }));
+        return withMeta(rows, { totalCount: rows.length, query: id });
+    },
+});

package/dist/clis/kegg/disease.d.ts

@@ -0,0 +1,6 @@
+/**
+ * kegg/disease — Find diseases linked to a KEGG gene.
+ *
+ * Shorthand for `kegg link --target disease`. Adds disease name resolution.
+ */
+export {};

package/dist/clis/kegg/disease.js

@@ -0,0 +1,57 @@
+/**
+ * kegg/disease — Find diseases linked to a KEGG gene.
+ *
+ * Shorthand for `kegg link --target disease`. Adds disease name resolution.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildKeggUrl, parseKeggTsv, parseKeggEntry } from '../../databases/kegg.js';
+import { withMeta } from '../../types.js';
+cli({
+    site: 'kegg',
+    name: 'disease',
+    description: 'Find diseases linked to a KEGG gene',
+    database: 'kegg',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'gene', positional: true, required: true, help: 'KEGG gene ID (e.g. hsa:7157)' },
+    ],
+    columns: ['geneId', 'diseaseId', 'diseaseName'],
+    func: async (ctx, args) => {
+        const gene = String(args.gene).trim();
+        // Step 1: Get disease links
+        const linkText = await ctx.fetchText(buildKeggUrl(`/link/disease/${gene}`));
+        if (!linkText.trim()) {
+            throw new CliError('NOT_FOUND', `No disease links found for ${gene}`, 'Check the gene ID (e.g. hsa:7157)');
+        }
+        const links = parseKeggTsv(linkText);
+        // Step 2: Get disease names (batch, max 10 per request)
+        const diseaseIds = links.map(l => l.value).filter(Boolean);
+        const names = {};
+        // Batch in groups of 10
+        for (let i = 0; i < diseaseIds.length; i += 10) {
+            const batch = diseaseIds.slice(i, i + 10);
+            try {
+                const text = await ctx.fetchText(buildKeggUrl(`/get/${batch.join('+')}`));
+                // Parse multiple entries separated by ///
+                const entries = text.split('///').filter(e => e.trim());
+                for (const entryText of entries) {
+                    const entry = parseKeggEntry(entryText);
+                    if (entry.ENTRY && entry.NAME) {
+                        const id = 'ds:' + entry.ENTRY.split(/\s+/)[0];
+                        names[id] = entry.NAME;
+                    }
+                }
+            }
+            catch {
+                // Non-fatal — display without names
+            }
+        }
+        const rows = links.map(l => ({
+            geneId: l.key,
+            diseaseId: l.value,
+            diseaseName: names[l.value] ?? '',
+        }));
+        return withMeta(rows, { totalCount: rows.length, query: gene });
+    },
+});

package/dist/clis/kegg/link.d.ts

@@ -0,0 +1,7 @@
+/**
+ * kegg/link — Find cross-references for a gene in KEGG.
+ *
+ * Uses KEGG REST /link endpoint to find pathways, diseases, or
+ * other database cross-references for a given gene.
+ */
+export {};

package/dist/clis/kegg/link.js

@@ -0,0 +1,36 @@
+/**
+ * kegg/link — Find cross-references for a gene in KEGG.
+ *
+ * Uses KEGG REST /link endpoint to find pathways, diseases, or
+ * other database cross-references for a given gene.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildKeggUrl, parseKeggTsv } from '../../databases/kegg.js';
+import { withMeta } from '../../types.js';
+cli({
+    site: 'kegg',
+    name: 'link',
+    description: 'Find KEGG cross-references for a gene',
+    database: 'kegg',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'gene', positional: true, required: true, help: 'KEGG gene ID (e.g. hsa:7157) or comma-separated list' },
+        { name: 'target', default: 'pathway', choices: ['pathway', 'disease', 'drug', 'compound'], help: 'Target database to link to' },
+    ],
+    columns: ['source', 'target'],
+    func: async (ctx, args) => {
+        const gene = String(args.gene).trim();
+        const target = String(args.target);
+        const text = await ctx.fetchText(buildKeggUrl(`/link/${target}/${gene}`));
+        if (!text.trim()) {
+            throw new CliError('NOT_FOUND', `No ${target} links found for ${gene}`, 'Check the gene ID format (e.g. hsa:7157)');
+        }
+        const parsed = parseKeggTsv(text);
+        const rows = parsed.map(p => ({
+            source: p.key,
+            target: p.value,
+        }));
+        return withMeta(rows, { totalCount: rows.length, query: gene });
+    },
+});

package/dist/clis/kegg/pathway.d.ts

@@ -0,0 +1,6 @@
+/**
+ * kegg/pathway — Get KEGG pathway details.
+ *
+ * Uses KEGG REST /get endpoint to retrieve pathway information.
+ */
+export {};

package/dist/clis/kegg/pathway.js

@@ -0,0 +1,37 @@
+/**
+ * kegg/pathway — Get KEGG pathway details.
+ *
+ * Uses KEGG REST /get endpoint to retrieve pathway information.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildKeggUrl, parseKeggEntry } from '../../databases/kegg.js';
+cli({
+    site: 'kegg',
+    name: 'pathway',
+    description: 'Get KEGG pathway details',
+    database: 'kegg',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'KEGG pathway ID (e.g. hsa05200, hsa00600)' },
+    ],
+    columns: ['id', 'name', 'description', 'class', 'genes', 'diseases'],
+    func: async (ctx, args) => {
+        const id = String(args.id).trim();
+        const text = await ctx.fetchText(buildKeggUrl(`/get/${id}`));
+        if (!text || text.includes('No such')) {
+            throw new CliError('NOT_FOUND', `KEGG pathway ${id} not found`, 'Check the pathway ID (e.g. hsa05200)');
+        }
+        const entry = parseKeggEntry(text);
+        // Count genes: GENE field has lines like "7157  TP53; tumor protein p53"
+        const geneLines = (entry.GENE ?? '').split(/\d+\s+/).filter(Boolean);
+        return [{
+                id,
+                name: entry.NAME ?? '',
+                description: entry.DESCRIPTION ?? '',
+                class: entry.CLASS ?? '',
+                genes: `${geneLines.length} genes`,
+                diseases: entry.DISEASE ?? '',
+            }];
+    },
+});

package/dist/clis/pubmed/abstract.d.ts

@@ -0,0 +1,7 @@
+/**
+ * pubmed/abstract — Get abstract text for a PubMed article.
+ *
+ * Returns only the PMID and abstract text, defaulting to plain output
+ * format for easy piping and reading.
+ */
+export {};

package/dist/clis/pubmed/abstract.js

@@ -0,0 +1,42 @@
+/**
+ * pubmed/abstract — Get abstract text for a PubMed article.
+ *
+ * Returns only the PMID and abstract text, defaulting to plain output
+ * format for easy piping and reading.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildEutilsUrl } from '../_shared/eutils.js';
+import { parsePubmedArticles } from '../_shared/xml-helpers.js';
+cli({
+    site: 'pubmed',
+    name: 'abstract',
+    description: 'Get abstract text for a PubMed article',
+    database: 'pubmed',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'pmid', positional: true, required: true, help: 'PubMed ID' },
+    ],
+    columns: ['pmid', 'abstract'],
+    defaultFormat: 'plain',
+    func: async (ctx, args) => {
+        const pmid = String(args.pmid).trim();
+        if (!/^\d+$/.test(pmid)) {
+            throw new CliError('ARGUMENT', `Invalid PMID: "${pmid}"`, 'PMID must be a numeric identifier');
+        }
+        const xmlData = await ctx.fetchXml(buildEutilsUrl('efetch.fcgi', {
+            db: 'pubmed',
+            id: pmid,
+            rettype: 'xml',
+        }));
+        const articles = parsePubmedArticles(xmlData);
+        if (!articles.length) {
+            throw new CliError('NOT_FOUND', `Article PMID ${pmid} not found`, 'Check that the PMID is correct');
+        }
+        const article = articles[0];
+        if (!article.abstract) {
+            throw new CliError('EMPTY_RESULT', `No abstract available for PMID ${pmid}`, 'This article may not have an abstract');
+        }
+        return [{ pmid: article.pmid, abstract: article.abstract }];
+    },
+});

package/dist/clis/pubmed/cited-by.d.ts

@@ -0,0 +1,7 @@
+/**
+ * pubmed/cited-by — Find articles that cite a given PubMed article.
+ *
+ * Uses elink with linkname 'pubmed_pubmed_citedin' to discover citing
+ * PMIDs, then efetch to retrieve article metadata.
+ */
+export {};