publishport-opencli 1.8.4-pp.1

package/clis/producthunt/utils.js

@@ -0,0 +1,99 @@
+/**
+ * Product Hunt shared helpers.
+ */
+export const PRODUCTHUNT_CATEGORY_SLUGS = [
+    'ai-agents',
+    'ai-coding-agents',
+    'ai-code-editors',
+    'ai-chatbots',
+    'ai-workflow-automation',
+    'vibe-coding',
+    'developer-tools',
+    'productivity',
+    'design-creative',
+    'marketing-sales',
+    'no-code-platforms',
+    'llms',
+    'finance',
+    'social-community',
+    'engineering-development',
+];
+const UA = 'Mozilla/5.0 (compatible; opencli/1.0)';
+/**
+ * Fetch Product Hunt Atom RSS feed.
+ * @param category  Optional category slug (e.g. "ai", "developer-tools")
+ */
+export async function fetchFeed(category) {
+    const url = category
+        ? `https://www.producthunt.com/feed?category=${encodeURIComponent(category)}`
+        : 'https://www.producthunt.com/feed';
+    const resp = await fetch(url, { headers: { 'User-Agent': UA } });
+    if (!resp.ok)
+        return [];
+    const xml = await resp.text();
+    return parseFeed(xml);
+}
+export function parseFeed(xml) {
+    const posts = [];
+    const entryRegex = /<entry>([\s\S]*?)<\/entry>/g;
+    let match;
+    let rank = 1;
+    while ((match = entryRegex.exec(xml))) {
+        const block = match[1];
+        const name = block.match(/<title>([\s\S]*?)<\/title>/)?.[1]?.trim() ?? '';
+        const author = block.match(/<name>([\s\S]*?)<\/name>/)?.[1]?.trim() ?? '';
+        const pubRaw = block.match(/<published>(.*?)<\/published>/)?.[1]?.trim() ?? '';
+        const date = pubRaw.slice(0, 10);
+        const link = block.match(/<link[^>]*href="([^"]+)"/)?.[1]?.trim() ?? '';
+        // Extract tagline from HTML content (first <p> text)
+        const contentRaw = block.match(/<content[^>]*>([\s\S]*?)<\/content>/)?.[1] ?? '';
+        const contentDecoded = contentRaw
+            .replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').replace(/&quot;/g, '"');
+        const tagline = contentDecoded
+            .replace(/<[^>]+>/g, ' ')
+            .replace(/\s+/g, ' ')
+            .replace(/\s*Discussion\s*\|?\s*/gi, '')
+            .replace(/\s*\|?\s*Link\s*$/gi, '')
+            .trim()
+            .slice(0, 120);
+        if (name) {
+            posts.push({ rank: rank++, name, tagline, author, date, url: link });
+        }
+    }
+    return posts;
+}
+export function pickVoteCount(candidates) {
+    const scored = candidates
+        .map((candidate) => {
+        const text = String(candidate.text ?? '').trim();
+        if (!/^\d+$/.test(text))
+            return null;
+        if (candidate.inReviewLink)
+            return null;
+        const value = parseInt(text, 10);
+        if (!Number.isFinite(value) || value <= 0)
+            return null;
+        const signal = `${candidate.tagName ?? ''} ${candidate.className ?? ''} ${candidate.role ?? ''}`.toLowerCase();
+        let score = 0;
+        if (candidate.inButton)
+            score += 4;
+        if (signal.includes('vote') || signal.includes('upvote'))
+            score += 3;
+        if (signal.includes('button'))
+            score += 1;
+        return { text, score, value };
+    })
+        .filter((candidate) => Boolean(candidate))
+        .sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        if (b.value !== a.value)
+            return b.value - a.value;
+        return a.text.localeCompare(b.text);
+    });
+    return scored[0]?.text ?? '';
+}
+/** Format ISO date string to YYYY-MM-DD */
+export function toDate(iso) {
+    return iso.slice(0, 10);
+}

package/clis/producthunt/utils.test.js

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest';
+import { parseFeed, pickVoteCount, PRODUCTHUNT_CATEGORY_SLUGS } from './utils.js';
+const SAMPLE_ATOM = `<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title>Product Hunt</title>
+  <entry>
+    <id>tag:www.producthunt.com,2005:Post/1001</id>
+    <published>2026-03-26T10:00:00-07:00</published>
+    <title>Awesome AI Tool</title>
+    <content type="html">&lt;p&gt;The best AI tool ever made&lt;/p&gt;&lt;p&gt;&lt;a href="..."&gt;Discussion&lt;/a&gt;&lt;/p&gt;</content>
+    <author><name>Jane Doe</name></author>
+    <link rel="alternate" type="text/html" href="https://www.producthunt.com/products/awesome-ai-tool"/>
+  </entry>
+  <entry>
+    <id>tag:www.producthunt.com,2005:Post/1002</id>
+    <published>2026-03-25T08:00:00-07:00</published>
+    <title>Dev Helper</title>
+    <content type="html">&lt;p&gt;Speeds up your workflow&lt;/p&gt;</content>
+    <author><name>John Smith</name></author>
+    <link rel="alternate" type="text/html" href="https://www.producthunt.com/products/dev-helper"/>
+  </entry>
+</feed>`;
+describe('parseFeed', () => {
+    it('parses entries into ranked posts', () => {
+        const posts = parseFeed(SAMPLE_ATOM);
+        expect(posts).toHaveLength(2);
+        expect(posts[0].rank).toBe(1);
+        expect(posts[0].name).toBe('Awesome AI Tool');
+        expect(posts[0].author).toBe('Jane Doe');
+        expect(posts[0].date).toBe('2026-03-26');
+        expect(posts[0].url).toBe('https://www.producthunt.com/products/awesome-ai-tool');
+        expect(posts[0].tagline).toContain('best AI tool');
+    });
+    it('strips HTML and Discussion link from tagline', () => {
+        const posts = parseFeed(SAMPLE_ATOM);
+        expect(posts[0].tagline).not.toContain('<p>');
+        expect(posts[0].tagline).not.toContain('Discussion');
+    });
+    it('returns empty array for empty feed', () => {
+        expect(parseFeed('<feed></feed>')).toHaveLength(0);
+    });
+    it('assigns sequential ranks', () => {
+        const posts = parseFeed(SAMPLE_ATOM);
+        expect(posts.map(p => p.rank)).toEqual([1, 2]);
+    });
+    it('prefers vote-like candidates over unrelated numeric badges', () => {
+        const votes = pickVoteCount([
+            { text: '12', className: 'font-semibold', inButton: false, inReviewLink: false },
+            { text: '98', className: 'vote-button', inButton: true, inReviewLink: false },
+        ]);
+        expect(votes).toBe('98');
+    });
+    it('ignores numbers inside review links', () => {
+        const votes = pickVoteCount([
+            { text: '120', className: 'text-secondary', inButton: false, inReviewLink: true },
+            { text: '45', className: 'vote-button', inButton: true, inReviewLink: false },
+        ]);
+        expect(votes).toBe('45');
+    });
+    it('shares category slugs across commands', () => {
+        expect(PRODUCTHUNT_CATEGORY_SLUGS).toContain('developer-tools');
+        expect(PRODUCTHUNT_CATEGORY_SLUGS).toContain('ai-agents');
+    });
+});

package/clis/pubmed/article.js

@@ -0,0 +1,55 @@
+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,
+    defaultFormat: 'plain',
+    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: ['pmid', 'title', 'authors', 'journal', 'year', 'date', 'article_type', 'language', 'doi', 'pmc', 'affiliations', 'grants', 'mesh_terms', 'keywords', 'abstract', 'url'],
+    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 [
+            {
+                pmid: article.pmid,
+                title: article.title,
+                authors: article.authors.join(', '),
+                journal: article.journal,
+                year: article.year,
+                date: article.date || null,
+                article_type: article.article_type,
+                language: article.language || null,
+                doi: article.doi || null,
+                pmc: article.pmc || null,
+                affiliations: article.affiliations || null,
+                grants: article.grants || null,
+                mesh_terms: article.mesh_terms || null,
+                keywords: article.keywords || null,
+                abstract: abstract || null,
+                url: 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');
+    },
+});

package/clis/pubmed/clinical-trial.js

@@ -0,0 +1,59 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    SEARCH_COLUMNS,
+    buildSearchQuery,
+    eutilsFetch,
+    fetchSummaryRows,
+    requireBoundedInt,
+    requireChoice,
+    requireText,
+    requireYear,
+} from './utils.js';
+
+cli({
+    site: 'pubmed',
+    name: 'clinical-trial',
+    access: 'read',
+    description: 'Search PubMed clinical trials with a trial-study preset',
+    domain: 'pubmed.ncbi.nlm.nih.gov',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Clinical topic query, e.g. "breast cancer"' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results (1-100)' },
+        { name: 'year-from', type: 'int', help: 'Filter publication year from' },
+        { name: 'year-to', type: 'int', help: 'Filter publication year to' },
+        { name: 'free-full-text', type: 'boolean', default: false, help: 'Only include free full text articles' },
+        { name: 'sort', default: 'date', choices: ['date', 'relevance'], help: 'Sort by date or relevance' },
+    ],
+    columns: SEARCH_COLUMNS,
+    func: async (args) => {
+        const query = requireText(args.query, 'query');
+        const limit = requireBoundedInt(args.limit, 20, 100);
+        const yearFrom = requireYear(args['year-from'], 'year-from');
+        const yearTo = requireYear(args['year-to'], 'year-to');
+        const sort = requireChoice(args.sort, ['date', 'relevance'], 'sort', 'date');
+        const searchQuery = buildSearchQuery(query, {
+            yearFrom,
+            yearTo,
+            articleType: 'Clinical Trial',
+            hasFullText: args['free-full-text'],
+            humanOnly: true,
+        });
+        const esearch = await eutilsFetch('esearch', {
+            term: searchQuery,
+            retmax: limit,
+            usehistory: 'y',
+            sort: sort === 'date' ? 'pub_date' : '',
+        }, { label: 'pubmed clinical-trial' });
+        const pmids = esearch?.esearchresult?.idlist;
+        if (!Array.isArray(pmids)) {
+            throw new CommandExecutionError('pubmed clinical-trial did not return an id list', 'PubMed ESearch response shape may have changed.');
+        }
+        if (pmids.length === 0) {
+            throw new EmptyResultError('pubmed clinical-trial', `No clinical trial articles matched "${query}".`);
+        }
+        return fetchSummaryRows(pmids, 'pubmed clinical-trial summary');
+    },
+});

package/clis/pubmed/journal.js

@@ -0,0 +1,59 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    SEARCH_COLUMNS,
+    eutilsFetch,
+    fetchSummaryRows,
+    requireBoundedInt,
+    requireChoice,
+    requireText,
+    requireYear,
+} from './utils.js';
+
+cli({
+    site: 'pubmed',
+    name: 'journal',
+    access: 'read',
+    description: 'Search PubMed articles by journal name',
+    domain: 'pubmed.ncbi.nlm.nih.gov',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'journal', positional: true, required: true, help: 'Journal name, e.g. "Nature" or "The Lancet"' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results (1-100)' },
+        { name: 'year-from', type: 'int', help: 'Filter publication year from' },
+        { name: 'year-to', type: 'int', help: 'Filter publication year to' },
+        { name: 'sort', default: 'relevance', choices: ['relevance', 'date'], help: 'Sort by relevance or date' },
+    ],
+    columns: SEARCH_COLUMNS,
+    func: async (args) => {
+        const journal = requireText(args.journal, 'journal');
+        const limit = requireBoundedInt(args.limit, 20, 100);
+        const yearFrom = requireYear(args['year-from'], 'year-from');
+        const yearTo = requireYear(args['year-to'], 'year-to');
+        const sort = requireChoice(args.sort, ['relevance', 'date'], 'sort', 'relevance');
+        const terms = [`${journal}[Journal]`];
+        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 journal' });
+        const pmids = esearch?.esearchresult?.idlist;
+        if (!Array.isArray(pmids)) {
+            throw new CommandExecutionError('pubmed journal did not return an id list', 'PubMed ESearch response shape may have changed.');
+        }
+        if (pmids.length === 0) {
+            throw new EmptyResultError('pubmed journal', `No articles found for journal "${journal}".`);
+        }
+        return fetchSummaryRows(pmids, 'pubmed journal summary');
+    },
+});

package/clis/pubmed/mesh.js

@@ -0,0 +1,47 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    SEARCH_COLUMNS,
+    eutilsFetch,
+    fetchSummaryRows,
+    requireBoundedInt,
+    requireChoice,
+    requireText,
+} from './utils.js';
+
+cli({
+    site: 'pubmed',
+    name: 'mesh',
+    access: 'read',
+    description: 'Search PubMed articles by MeSH term',
+    domain: 'pubmed.ncbi.nlm.nih.gov',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'term', positional: true, required: true, help: 'MeSH term, e.g. "Neoplasms" or "Machine Learning"' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results (1-100)' },
+        { name: 'major', type: 'boolean', default: false, help: 'Only include articles where this is a major MeSH topic' },
+        { name: 'sort', default: 'relevance', choices: ['relevance', 'date'], help: 'Sort by relevance or date' },
+    ],
+    columns: SEARCH_COLUMNS,
+    func: async (args) => {
+        const term = requireText(args.term, 'term');
+        const limit = requireBoundedInt(args.limit, 20, 100);
+        const sort = requireChoice(args.sort, ['relevance', 'date'], 'sort', 'relevance');
+        const tag = args.major ? 'Majr' : 'MeSH Terms';
+        const esearch = await eutilsFetch('esearch', {
+            term: `${term}[${tag}]`,
+            retmax: limit,
+            usehistory: 'y',
+            sort: sort === 'date' ? 'pub_date' : '',
+        }, { label: 'pubmed mesh' });
+        const pmids = esearch?.esearchresult?.idlist;
+        if (!Array.isArray(pmids)) {
+            throw new CommandExecutionError('pubmed mesh did not return an id list', 'PubMed ESearch response shape may have changed.');
+        }
+        if (pmids.length === 0) {
+            throw new EmptyResultError('pubmed mesh', `No articles found for MeSH term "${term}".`);
+        }
+        return fetchSummaryRows(pmids, 'pubmed mesh summary');
+    },
+});