@jackwener/opencli 1.4.1 → 1.5.1

package/dist/clis/paperreview/utils.js

@@ -0,0 +1,197 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { CliError, getErrorMessage } from '../../errors.js';
+export const PAPERREVIEW_DOMAIN = 'paperreview.ai';
+export const PAPERREVIEW_BASE_URL = `https://${PAPERREVIEW_DOMAIN}`;
+export const MAX_PDF_BYTES = 10 * 1024 * 1024;
+function asText(value) {
+    return value == null ? '' : String(value);
+}
+function trimOrEmpty(value) {
+    return asText(value).trim();
+}
+function toErrorMessage(payload, fallback) {
+    if (payload && typeof payload === 'object') {
+        const detail = trimOrEmpty(payload.detail);
+        const message = trimOrEmpty(payload.message);
+        const error = trimOrEmpty(payload.error);
+        if (detail)
+            return detail;
+        if (message)
+            return message;
+        if (error)
+            return error;
+    }
+    const text = trimOrEmpty(payload);
+    return text || fallback;
+}
+export function buildReviewUrl(token) {
+    return `${PAPERREVIEW_BASE_URL}/review?token=${encodeURIComponent(token)}`;
+}
+export function parseYesNo(value, name) {
+    const normalized = trimOrEmpty(value).toLowerCase();
+    if (normalized === 'yes')
+        return true;
+    if (normalized === 'no')
+        return false;
+    throw new CliError('ARGUMENT', `"${name}" must be either "yes" or "no".`);
+}
+export function normalizeVenue(value) {
+    return trimOrEmpty(value);
+}
+export function validateHelpfulness(value) {
+    const numeric = Number(value);
+    if (!Number.isInteger(numeric) || numeric < 1 || numeric > 5) {
+        throw new CliError('ARGUMENT', '"helpfulness" must be an integer from 1 to 5.');
+    }
+    return numeric;
+}
+export async function readPdfFile(inputPath) {
+    const rawPath = trimOrEmpty(inputPath);
+    if (!rawPath) {
+        throw new CliError('ARGUMENT', 'A PDF path is required.', 'Provide a local PDF file path');
+    }
+    const resolvedPath = path.resolve(rawPath);
+    const fileName = path.basename(resolvedPath);
+    if (!fileName.toLowerCase().endsWith('.pdf')) {
+        throw new CliError('ARGUMENT', 'The input file must end with .pdf.', 'Provide a PDF file path');
+    }
+    let fileStat;
+    try {
+        fileStat = await fs.stat(resolvedPath);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            throw new CliError('FILE_NOT_FOUND', `File not found: ${resolvedPath}`, 'Provide a valid PDF file path');
+        }
+        throw new CliError('FILE_READ_ERROR', `Unable to inspect file: ${resolvedPath}`, 'Check file permissions and try again');
+    }
+    if (!fileStat.isFile()) {
+        throw new CliError('FILE_NOT_FOUND', `Not a file: ${resolvedPath}`, 'Provide a valid PDF file path');
+    }
+    if (fileStat.size < 100) {
+        throw new CliError('ARGUMENT', 'The PDF is too small. paperreview.ai requires at least 100 bytes.', 'Provide the final paper PDF');
+    }
+    if (fileStat.size > MAX_PDF_BYTES) {
+        throw new CliError('FILE_TOO_LARGE', 'The PDF is larger than paperreview.ai\'s 10MB limit.', 'Compress the PDF or submit a smaller file');
+    }
+    let buffer;
+    try {
+        buffer = await fs.readFile(resolvedPath);
+    }
+    catch {
+        throw new CliError('FILE_READ_ERROR', `Unable to read file: ${resolvedPath}`, 'Check file permissions and try again');
+    }
+    return {
+        buffer,
+        fileName,
+        resolvedPath,
+        sizeBytes: buffer.byteLength,
+    };
+}
+export async function requestJson(pathname, init = {}) {
+    let response;
+    try {
+        response = await fetch(`${PAPERREVIEW_BASE_URL}${pathname}`, init);
+    }
+    catch (error) {
+        throw new CliError('FETCH_ERROR', `Unable to reach paperreview.ai: ${getErrorMessage(error)}`, 'Check your network connection and try again');
+    }
+    const rawText = await response.text();
+    let payload = rawText;
+    if (rawText) {
+        try {
+            payload = JSON.parse(rawText);
+        }
+        catch {
+            payload = rawText;
+        }
+    }
+    return { response, payload };
+}
+export function ensureSuccess(response, payload, fallback, hint) {
+    if (!response.ok) {
+        const code = response.status === 404 ? 'NOT_FOUND' : 'API_ERROR';
+        throw new CliError(code, toErrorMessage(payload, fallback), hint);
+    }
+}
+export function ensureApiSuccess(payload, fallback, hint) {
+    if (!payload || typeof payload !== 'object' || payload.success !== true) {
+        throw new CliError('API_ERROR', toErrorMessage(payload, fallback), hint);
+    }
+}
+export function createUploadForm(urlData, pdfFile) {
+    const form = new FormData();
+    for (const [key, value] of Object.entries(urlData.presigned_fields ?? {})) {
+        form.append(key, value);
+    }
+    form.append('file', new Blob([new Uint8Array(pdfFile.buffer)], { type: 'application/pdf' }), pdfFile.fileName);
+    return form;
+}
+export async function uploadPresignedPdf(presignedUrl, pdfFile, urlData) {
+    let response;
+    try {
+        response = await fetch(presignedUrl, {
+            method: 'POST',
+            body: createUploadForm(urlData, pdfFile),
+        });
+    }
+    catch (error) {
+        throw new CliError('UPLOAD_ERROR', `S3 upload failed: ${getErrorMessage(error)}`, 'Try again in a moment');
+    }
+    if (!response.ok) {
+        const body = await response.text();
+        throw new CliError('UPLOAD_ERROR', body || `S3 upload failed with status ${response.status}.`, 'Try again in a moment');
+    }
+}
+export function summarizeSubmission(options) {
+    const { pdfFile, email, venue, token, message, s3Key, dryRun = false, status } = options;
+    return {
+        status: status ?? (dryRun ? 'dry-run' : 'submitted'),
+        file: pdfFile.fileName,
+        file_path: pdfFile.resolvedPath,
+        size_bytes: pdfFile.sizeBytes,
+        email,
+        venue,
+        token: token ?? '',
+        review_url: token ? buildReviewUrl(token) : '',
+        message: message ?? '',
+        s3_key: s3Key ?? '',
+    };
+}
+export function summarizeReview(token, payload, status = 'ready') {
+    const sections = payload?.sections ?? {};
+    const availableSections = Object.keys(sections);
+    return {
+        status,
+        token,
+        review_url: buildReviewUrl(token),
+        title: trimOrEmpty(payload?.title),
+        venue: trimOrEmpty(payload?.venue),
+        submission_date: trimOrEmpty(payload?.submission_date),
+        numerical_score: payload?.numerical_score ?? '',
+        has_feedback: payload?.has_feedback ?? '',
+        available_sections: availableSections.join(', '),
+        section_count: availableSections.length,
+        summary: trimOrEmpty(sections.summary),
+        strengths: trimOrEmpty(sections.strengths),
+        weaknesses: trimOrEmpty(sections.weaknesses),
+        detailed_comments: trimOrEmpty(sections.detailed_comments),
+        questions: trimOrEmpty(sections.questions),
+        assessment: trimOrEmpty(sections.assessment),
+        content: trimOrEmpty(payload?.content),
+        sections,
+    };
+}
+export function summarizeFeedback(options) {
+    const { token, helpfulness, criticalError, actionableSuggestions, comments, payload } = options;
+    return {
+        status: 'submitted',
+        token,
+        helpfulness,
+        critical_error: criticalError,
+        actionable_suggestions: actionableSuggestions,
+        additional_comments: comments,
+        message: trimOrEmpty(payload?.message) || 'Feedback submitted.',
+    };
+}

package/dist/clis/paperreview/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/paperreview/utils.test.js

@@ -0,0 +1,49 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CliError } from '../../errors.js';
+import { MAX_PDF_BYTES, buildReviewUrl, parseYesNo, readPdfFile, requestJson, validateHelpfulness, } from './utils.js';
+describe('paperreview utils', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('builds review URLs from the token', () => {
+        expect(buildReviewUrl('tok 123')).toBe('https://paperreview.ai/review?token=tok%20123');
+    });
+    it('parses yes/no flags', () => {
+        expect(parseYesNo('yes', 'critical-error')).toBe(true);
+        expect(parseYesNo('NO', 'critical-error')).toBe(false);
+    });
+    it('rejects invalid yes/no flags with CliError', () => {
+        expect(() => parseYesNo('maybe', 'critical-error')).toThrow(CliError);
+        expect(() => parseYesNo('maybe', 'critical-error')).toThrow('"critical-error" must be either "yes" or "no".');
+    });
+    it('validates helpfulness scores', () => {
+        expect(validateHelpfulness(5)).toBe(5);
+        expect(() => validateHelpfulness(0)).toThrow(CliError);
+    });
+    it('reads a valid PDF file and returns metadata', async () => {
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'paperreview-'));
+        const pdfPath = path.join(tempDir, 'sample.pdf');
+        const pdfBytes = Buffer.concat([Buffer.from('%PDF-1.4\n'), Buffer.alloc(256, 1)]);
+        await fs.writeFile(pdfPath, pdfBytes);
+        const result = await readPdfFile(pdfPath);
+        expect(result.fileName).toBe('sample.pdf');
+        expect(result.resolvedPath).toBe(pdfPath);
+        expect(result.sizeBytes).toBe(pdfBytes.length);
+        expect(result.buffer.equals(pdfBytes)).toBe(true);
+    });
+    it('rejects PDFs larger than the paperreview.ai size limit', async () => {
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'paperreview-'));
+        const pdfPath = path.join(tempDir, 'large.pdf');
+        await fs.writeFile(pdfPath, Buffer.alloc(MAX_PDF_BYTES + 1, 1));
+        await expect(readPdfFile(pdfPath)).rejects.toThrow(CliError);
+        await expect(readPdfFile(pdfPath)).rejects.toThrow('The PDF is larger than paperreview.ai\'s 10MB limit.');
+    });
+    it('normalizes fetch failures into CliError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('socket hang up')));
+        await expect(requestJson('/api/review/token')).rejects.toThrow(CliError);
+        await expect(requestJson('/api/review/token')).rejects.toThrow('Unable to reach paperreview.ai');
+    });
+});

package/dist/clis/producthunt/browse.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/producthunt/browse.js

@@ -0,0 +1,99 @@
+/**
+ * Product Hunt category browse — INTERCEPT strategy.
+ *
+ * Navigates to a Product Hunt category page and scrapes the top-rated products.
+ * Shows all-time best products for a category (ranked by review score, not daily votes).
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { PRODUCTHUNT_CATEGORY_SLUGS } from './utils.js';
+cli({
+    site: 'producthunt',
+    name: 'browse',
+    description: 'Best products in a Product Hunt category',
+    domain: 'www.producthunt.com',
+    strategy: Strategy.INTERCEPT,
+    args: [
+        {
+            name: 'category',
+            type: 'string',
+            positional: true,
+            required: true,
+            help: `Category slug, e.g. vibe-coding, ai-agents, developer-tools`,
+        },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results (max 50)' },
+    ],
+    columns: ['rank', 'name', 'tagline', 'reviews', 'url'],
+    func: async (page, args) => {
+        const count = Math.min(Number(args.limit) || 20, 50);
+        const slug = String(args.category || '').trim().toLowerCase();
+        await page.installInterceptor('producthunt.com');
+        await page.goto(`https://www.producthunt.com/categories/${slug}`);
+        await page.wait(5);
+        const domItems = await page.evaluate(`
+      (() => {
+        const seen = new Set();
+        const results = [];
+
+        // Card links: <a class="...flex-col" href="/products/<slug>"> (not review links)
+        const cardLinks = Array.from(document.querySelectorAll('a[href^="/products/"]')).filter(a => {
+          const href = a.getAttribute('href') || '';
+          const cls = a.className || '';
+          return cls.includes('flex-col') && !href.includes('/reviews');
+        });
+
+        for (const cardLink of cardLinks) {
+          const href = cardLink.getAttribute('href');
+          if (!href || seen.has(href)) continue;
+
+          // Child 0: div with name (strip "Launched this month/week/year" noise)
+          const nameDiv = cardLink.querySelector('div');
+          const rawName = nameDiv?.textContent?.trim() || '';
+          const name = rawName
+            .replace(/\\s*Launched\\s+this\\s+(month|week|year|day)\\s*/gi, '')
+            .replace(/\\s*Featured\\s*/gi, '')
+            .trim();
+
+          // Child 1: span.text-secondary — tagline
+          const taglineEl = cardLink.querySelector('span.text-secondary, span[class*="text-secondary"]');
+          const tagline = taglineEl?.textContent?.trim() || '';
+
+          if (!name) continue;
+
+          // Find reviews count from sibling /reviews link
+          let reviews = '';
+          let container = cardLink.parentElement;
+          for (let i = 0; i < 5 && container; i++) {
+            const reviewLink = container.querySelector('a[href="' + href + '/reviews"]');
+            if (reviewLink) {
+              reviews = (reviewLink.textContent?.trim() || '').replace(/\\s*reviews?\\s*/i, '').trim();
+              break;
+            }
+            container = container.parentElement;
+          }
+
+          seen.add(href);
+          results.push({
+            name,
+            tagline: tagline.slice(0, 120),
+            reviews: reviews || '0',
+            url: 'https://www.producthunt.com' + href,
+          });
+        }
+
+        return results;
+      })()
+    `);
+        const items = Array.isArray(domItems) ? domItems : [];
+        if (items.length === 0) {
+            throw new CliError('NO_DATA', `No products found for category "${slug}"`, 'Check the category slug or try: ' + PRODUCTHUNT_CATEGORY_SLUGS.slice(0, 5).join(', '));
+        }
+        return items.slice(0, count).map((item, i) => ({
+            rank: i + 1,
+            name: item.name,
+            tagline: item.tagline,
+            reviews: item.reviews,
+            url: item.url,
+        }));
+    },
+});

package/dist/clis/producthunt/hot.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/producthunt/hot.js

@@ -0,0 +1,110 @@
+/**
+ * Product Hunt top posts with vote counts — INTERCEPT strategy.
+ *
+ * Navigates to the Product Hunt homepage and scrapes rendered product cards.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { pickVoteCount } from './utils.js';
+cli({
+    site: 'producthunt',
+    name: 'hot',
+    description: "Today's top Product Hunt launches with vote counts",
+    domain: 'www.producthunt.com',
+    strategy: Strategy.INTERCEPT,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results (max 50)' },
+    ],
+    columns: ['rank', 'name', 'votes', 'url'],
+    func: async (page, args) => {
+        const count = Math.min(Number(args.limit) || 20, 50);
+        await page.installInterceptor('producthunt.com');
+        await page.goto('https://www.producthunt.com');
+        await page.wait(5);
+        const domItems = await page.evaluate(`
+      (() => {
+        const seen = new Set();
+        const results = [];
+
+        const cardLinks = Array.from(document.querySelectorAll('a[href^="/products/"]')).filter((el) => {
+          const href = el.getAttribute('href') || '';
+          const text = el.textContent?.trim() || '';
+          return href && !href.includes('/reviews') && text.length > 0 && text.length < 120;
+        });
+
+        const normalizeName = (text) => text
+          .replace(/^\\d+\\.\\s*/, '')
+          .replace(/\\s*Launched\\s+this\\s+(month|week|year|day)\\s*/gi, '')
+          .replace(/\\s*Featured\\s*/gi, '')
+          .trim();
+
+        for (const cardLink of cardLinks) {
+          const href = cardLink.getAttribute('href') || '';
+          if (!href || seen.has(href)) continue;
+
+          let card = cardLink;
+          let node = cardLink.parentElement;
+          for (let i = 0; i < 6 && node; i++) {
+            const hasReviewLink = !!node.querySelector('a[href="' + href + '/reviews"]');
+            const hasNumericNode = Array.from(node.querySelectorAll('button, [role="button"], p, span, div'))
+              .some((el) => /^\\d+$/.test(el.textContent?.trim() || ''));
+            if (hasReviewLink || hasNumericNode) {
+              card = node;
+              break;
+            }
+            node = node.parentElement;
+          }
+
+          const name = normalizeName(cardLink.textContent?.trim() || '');
+          if (!name) continue;
+
+          const voteCandidates = Array.from(card.querySelectorAll('button, [role="button"], a, p, span, div'))
+            .map((el) => {
+              const reviewLink = el.closest('a[href="' + href + '/reviews"]');
+              return {
+                text: el.textContent?.trim() || '',
+                tagName: el.tagName,
+                className: el.className || '',
+                role: el.getAttribute('role') || '',
+                inButton: !!el.closest('button, [role="button"]'),
+                inReviewLink: !!reviewLink,
+              };
+            })
+            .filter((candidate) => /^\\d+$/.test(candidate.text));
+
+          if (voteCandidates.length === 0) continue;
+
+          seen.add(href);
+          results.push({
+            name,
+            voteCandidates,
+            url: 'https://www.producthunt.com' + href,
+          });
+        }
+
+        return results;
+      })()
+    `);
+        const items = Array.isArray(domItems) ? domItems : [];
+        if (items.length === 0) {
+            throw new CliError('NO_DATA', 'Could not retrieve Product Hunt top posts', 'Product Hunt may have changed its layout');
+        }
+        const rankedItems = items
+            .map((item) => ({
+            name: item.name,
+            url: item.url,
+            votes: pickVoteCount(Array.isArray(item.voteCandidates) ? item.voteCandidates : []),
+        }))
+            .filter((item) => item.name && item.url && item.votes);
+        if (rankedItems.length === 0) {
+            throw new CliError('NO_DATA', 'Could not retrieve Product Hunt vote counts', 'Product Hunt may have changed its vote button structure');
+        }
+        rankedItems.sort((a, b) => parseInt(b.votes, 10) - parseInt(a.votes, 10));
+        return rankedItems.slice(0, count).map((item, i) => ({
+            rank: i + 1,
+            name: item.name,
+            votes: item.votes,
+            url: item.url,
+        }));
+    },
+});

package/dist/clis/producthunt/posts.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/producthunt/posts.js

@@ -0,0 +1,28 @@
+/**
+ * Product Hunt latest posts — public Atom feed, no browser needed.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { fetchFeed, PRODUCTHUNT_CATEGORY_SLUGS } from './utils.js';
+cli({
+    site: 'producthunt',
+    name: 'posts',
+    description: 'Latest Product Hunt launches (optional category filter)',
+    domain: 'www.producthunt.com',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results (max 50)' },
+        {
+            name: 'category',
+            type: 'string',
+            default: '',
+            help: `Category filter: ${PRODUCTHUNT_CATEGORY_SLUGS.join(', ')}`,
+        },
+    ],
+    columns: ['rank', 'name', 'tagline', 'author', 'date', 'url'],
+    func: async (_page, args) => {
+        const count = Math.min(Number(args.limit) || 20, 50);
+        const category = String(args.category ?? '').trim() || undefined;
+        const posts = await fetchFeed(category);
+        return posts.slice(0, count);
+    },
+});

package/dist/clis/producthunt/today.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/producthunt/today.js

@@ -0,0 +1,35 @@
+/**
+ * Product Hunt today's top launches — filtered from public Atom feed.
+ *
+ * Shows the most recently published day's products (Product Hunt runs on
+ * Pacific Time; the feed date may differ from UTC local date by up to 1 day).
+ */
+import { cli, Strategy } from '../../registry.js';
+import { fetchFeed } from './utils.js';
+cli({
+    site: 'producthunt',
+    name: 'today',
+    description: "Today's Product Hunt launches (most recent day in feed)",
+    domain: 'www.producthunt.com',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Max results' },
+    ],
+    columns: ['rank', 'name', 'tagline', 'author', 'url'],
+    func: async (_page, args) => {
+        const count = Math.min(Number(args.limit) || 20, 50);
+        const posts = await fetchFeed();
+        if (posts.length === 0)
+            return [];
+        // Use the latest date in the feed (Product Hunt is PST-based)
+        const latestDate = posts.map(p => p.date).sort().reverse()[0];
+        const todayPosts = posts.filter(p => p.date === latestDate);
+        return todayPosts.slice(0, count).map((p, i) => ({
+            rank: i + 1,
+            name: p.name,
+            tagline: p.tagline,
+            author: p.author,
+            url: p.url,
+        }));
+    },
+});

package/dist/clis/producthunt/utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Product Hunt shared helpers.
+ */
+export interface PhPost {
+    rank: number;
+    name: string;
+    tagline: string;
+    author: string;
+    date: string;
+    url: string;
+}
+export interface ProductHuntVoteCandidate {
+    text: string;
+    tagName?: string;
+    className?: string;
+    role?: string;
+    inButton?: boolean;
+    inReviewLink?: boolean;
+}
+export declare const PRODUCTHUNT_CATEGORY_SLUGS: readonly ["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"];
+/**
+ * Fetch Product Hunt Atom RSS feed.
+ * @param category  Optional category slug (e.g. "ai", "developer-tools")
+ */
+export declare function fetchFeed(category?: string): Promise<PhPost[]>;
+export declare function parseFeed(xml: string): PhPost[];
+export declare function pickVoteCount(candidates: ProductHuntVoteCandidate[]): string;
+/** Format ISO date string to YYYY-MM-DD */
+export declare function toDate(iso: string): string;

package/dist/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/dist/clis/producthunt/utils.test.d.ts

@@ -0,0 +1 @@
+export {};