@iflow-mcp/jakeliume-webpeel 0.22.0

package/dist/ee/extractors/polymarket.js

@@ -0,0 +1,358 @@
+import { fetchJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// 33. Polymarket extractor — prediction market data via public APIs
+//     Supports: events, markets, profiles (@username), activity
+// ---------------------------------------------------------------------------
+// ── Shared helpers ────────────────────────────────────────────────────────────
+const fmtPct = (p) => {
+    const n = typeof p === 'string' ? parseFloat(p) : p;
+    if (isNaN(n))
+        return '?%';
+    return (n * 100).toFixed(1) + '%';
+};
+const fmtVol = (v) => {
+    const n = typeof v === 'string' ? parseFloat(v) : v;
+    if (isNaN(n) || n === 0)
+        return '$0';
+    if (n >= 1_000_000)
+        return `$${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `$${(n / 1_000).toFixed(1)}K`;
+    return `$${n.toFixed(2)}`;
+};
+const fmtDate = (d) => {
+    if (!d)
+        return '?';
+    return d.slice(0, 10);
+};
+const fmtNum = (n) => {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return n.toLocaleString('en-US');
+};
+function timeAgo(timestamp) {
+    const diff = Math.floor(Date.now() / 1000) - timestamp;
+    if (diff < 60)
+        return 'just now';
+    if (diff < 3600)
+        return `${Math.floor(diff / 60)}m ago`;
+    if (diff < 86400)
+        return `${Math.floor(diff / 3600)}h ago`;
+    if (diff < 604800)
+        return `${Math.floor(diff / 86400)}d ago`;
+    return new Date(timestamp * 1000).toISOString().slice(0, 10);
+}
+// ── Main extractor ────────────────────────────────────────────────────────────
+export async function polymarketExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const path = urlObj.pathname;
+    const domain = 'polymarket.com';
+    // --- Profile: /@username or /profile/@username ---
+    const profileUsernameMatch = path.match(/^\/(profile\/)?@([a-zA-Z0-9_.-]+)/);
+    const profileAddressMatch = path.match(/^\/(profile\/)?(0x[a-fA-F0-9]{40})/);
+    if (profileUsernameMatch || profileAddressMatch) {
+        try {
+            return await extractProfile(domain, profileUsernameMatch?.[2] || null, profileAddressMatch?.[2] || null);
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'Polymarket profile fetch failed:', e instanceof Error ? e.message : e);
+            return null; // Fall through to browser
+        }
+    }
+    // --- Event page: /event/<slug> ---
+    const eventMatch = path.match(/^\/event\/([^/?#]+)/);
+    if (eventMatch) {
+        return extractEvent(eventMatch[1], domain);
+    }
+    // --- Main/markets page ---
+    const isRootOrMarkets = path === '/' || path === '' || path === '/markets' || path.startsWith('/markets?');
+    if (isRootOrMarkets) {
+        return extractMarkets(domain);
+    }
+    return null;
+}
+// ── Profile extractor ─────────────────────────────────────────────────────────
+async function resolveWallet(username) {
+    // Fetch the SSR HTML to extract proxyWallet from embedded Next.js data
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 10_000);
+    try {
+        const resp = await fetch(`https://polymarket.com/@${encodeURIComponent(username)}`, {
+            headers: {
+                'User-Agent': 'webpeel/0.21 (https://webpeel.dev)',
+                'Accept': 'text/html',
+            },
+            signal: controller.signal,
+            redirect: 'follow',
+        });
+        clearTimeout(timer);
+        if (!resp.ok)
+            return null;
+        const html = await resp.text();
+        const match = html.match(/"proxyWallet":"(0x[a-fA-F0-9]{40})"/);
+        return match?.[1] || null;
+    }
+    catch {
+        clearTimeout(timer);
+        return null;
+    }
+}
+async function fetchAllActivity(wallet, maxTrades = 5000) {
+    const allTrades = [];
+    let offset = 0;
+    const limit = 500;
+    while (offset < maxTrades) {
+        const batch = await fetchJson(`https://data-api.polymarket.com/activity?user=${wallet}&limit=${limit}&offset=${offset}`);
+        if (!Array.isArray(batch) || batch.length === 0)
+            break;
+        allTrades.push(...batch);
+        if (batch.length < limit)
+            break;
+        offset += limit;
+    }
+    return allTrades;
+}
+async function extractProfile(domain, username, walletAddress) {
+    // Step 1: Resolve wallet
+    let wallet = walletAddress;
+    if (!wallet && username) {
+        wallet = await resolveWallet(username);
+    }
+    if (!wallet)
+        return null;
+    // Step 2: Parallel API calls
+    const [profileData, statsData, leaderboardData, valueData, tradedData] = await Promise.all([
+        fetchJson(`https://polymarket.com/api/profile/userData?address=${wallet}`).catch(() => null),
+        fetchJson(`https://data-api.polymarket.com/v1/user-stats?proxyAddress=${wallet}`).catch(() => null),
+        fetchJson(`https://data-api.polymarket.com/v1/leaderboard?timePeriod=all&orderBy=VOL&limit=1&user=${wallet}`).catch(() => null),
+        fetchJson(`https://data-api.polymarket.com/value?user=${wallet}`).catch(() => null),
+        fetchJson(`https://data-api.polymarket.com/traded?user=${wallet}`).catch(() => null),
+    ]);
+    // Step 3: Fetch positions + activity in parallel
+    const [positions, activity] = await Promise.all([
+        fetchJson(`https://data-api.polymarket.com/positions?user=${wallet}&sortBy=CURRENT&sortDirection=DESC&sizeThreshold=.1&limit=100&offset=0`).catch(() => []),
+        fetchAllActivity(wallet).catch(() => []),
+    ]);
+    // Extract data
+    const lb = Array.isArray(leaderboardData) && leaderboardData.length > 0 ? leaderboardData[0] : null;
+    const displayName = username || lb?.userName || profileData?.pseudonym || wallet.slice(0, 10) + '…';
+    const xUsername = lb?.xUsername || null;
+    const rank = lb?.rank ? `#${Number(lb.rank).toLocaleString('en-US')}` : '?';
+    const totalVol = lb?.vol ? fmtVol(lb.vol) : '?';
+    const pnl = lb?.pnl != null ? (lb.pnl >= 0 ? `+${fmtVol(lb.pnl)}` : `-${fmtVol(Math.abs(lb.pnl))}`) : '?';
+    const trades = statsData?.trades ?? tradedData?.traded ?? '?';
+    const largestWin = statsData?.largestWin ? fmtVol(statsData.largestWin) : '?';
+    const views = statsData?.views ? fmtNum(statsData.views) : '?';
+    const joinDate = statsData?.joinDate
+        ? new Date(statsData.joinDate).toLocaleDateString('en-US', { month: 'short', year: 'numeric' })
+        : '?';
+    // Build positions markdown
+    let positionsMd = '';
+    const posArr = Array.isArray(positions) ? positions : [];
+    if (posArr.length > 0) {
+        const posRows = posArr.slice(0, 30).map((p) => {
+            const title = (p.title || p.eventTitle || '?').substring(0, 50);
+            const side = p.outcome || '?';
+            const shares = p.size != null ? Number(p.size).toFixed(1) : '?';
+            const avgPrice = p.avgPrice != null ? `$${Number(p.avgPrice).toFixed(2)}` : '?';
+            const curVal = p.currentValue != null ? fmtVol(p.currentValue) : (p.size && p.curPrice ? fmtVol(p.size * p.curPrice) : '?');
+            return `| ${title} | ${side} | ${shares} | ${avgPrice} | ${curVal} |`;
+        }).join('\n');
+        positionsMd = `\n## Current Positions (${posArr.length})\n\n| Market | Side | Shares | Avg Price | Value |\n|--------|------|--------|-----------|-------|\n${posRows}\n`;
+    }
+    // Build activity markdown (last 50 for display)
+    let activityMd = '';
+    const actArr = Array.isArray(activity) ? activity : [];
+    if (actArr.length > 0) {
+        const actRows = actArr.slice(0, 50).map((t) => {
+            const time = t.timestamp ? timeAgo(t.timestamp) : '?';
+            const type = t.type === 'TRADE' ? (t.side === 'BUY' ? 'Buy' : 'Sell') : t.type || '?';
+            const title = (t.title || '?').substring(0, 50);
+            const amount = t.usdcSize != null ? fmtVol(t.usdcSize) : '?';
+            return `| ${time} | ${type} | ${title} | ${amount} |`;
+        }).join('\n');
+        activityMd = `\n## Recent Activity (showing ${Math.min(actArr.length, 50)} of ${actArr.length} trades)\n\n| Time | Type | Market | Amount |\n|------|------|--------|--------|\n${actRows}\n`;
+    }
+    // Build activity summary
+    let summaryMd = '';
+    if (actArr.length > 0) {
+        const timestamps = actArr.map((t) => t.timestamp).filter(Boolean);
+        const oldest = timestamps.length ? new Date(Math.min(...timestamps) * 1000).toISOString().slice(0, 10) : '?';
+        const newest = timestamps.length ? new Date(Math.max(...timestamps) * 1000).toISOString().slice(0, 10) : '?';
+        const actVolume = actArr.reduce((sum, t) => sum + (Number(t.usdcSize) || 0), 0);
+        // Volume by day
+        const byDay = {};
+        actArr.forEach((t) => {
+            if (!t.timestamp)
+                return;
+            const day = new Date(t.timestamp * 1000).toISOString().slice(0, 10);
+            byDay[day] = (byDay[day] || 0) + (Number(t.usdcSize) || 0);
+        });
+        const sortedDays = Object.entries(byDay).sort(([a], [b]) => b.localeCompare(a));
+        const topDays = sortedDays.slice(0, 7).map(([day, vol]) => `${day}: ${fmtVol(vol)}`).join(' · ');
+        // Type breakdown
+        const types = {};
+        actArr.forEach((t) => { types[t.type || 'UNKNOWN'] = (types[t.type || 'UNKNOWN'] || 0) + 1; });
+        const typeStr = Object.entries(types).map(([k, v]) => `${k}: ${v}`).join(', ');
+        summaryMd = `\n## Activity Summary\n\n- **Trades fetched:** ${actArr.length.toLocaleString('en-US')} (${typeStr})\n- **Date range:** ${oldest} → ${newest}\n- **Volume (fetched trades):** ${fmtVol(actVolume)}\n- **Recent days:** ${topDays}\n`;
+    }
+    // X/Twitter line
+    const xLine = xUsername ? ` | **X:** [@${xUsername}](https://x.com/${xUsername})` : '';
+    const cleanContent = `# 📊 Polymarket Profile: @${displayName}
+
+**Rank:** ${rank} | **Total Volume:** ${totalVol} | **P&L:** ${pnl}
+**Trades:** ${typeof trades === 'number' ? trades.toLocaleString('en-US') : trades} | **Largest Win:** ${largestWin} | **Views:** ${views}
+**Joined:** ${joinDate}${xLine}
+${positionsMd}${activityMd}${summaryMd}
+---
+*Source: [Polymarket](https://polymarket.com/@${displayName}) · Data via Polymarket APIs*`;
+    // Structured data: ALL raw data for programmatic use
+    const structured = {
+        username: displayName,
+        wallet,
+        profile: profileData || {},
+        stats: statsData || {},
+        leaderboard: lb || {},
+        value: valueData || {},
+        positions: posArr,
+        activity: actArr,
+        summary: {
+            totalTrades: trades,
+            totalVolume: lb?.vol ?? null,
+            pnl: lb?.pnl ?? null,
+            rank: lb?.rank ?? null,
+            dateRange: actArr.length > 0 ? {
+                from: new Date(Math.min(...actArr.map((t) => t.timestamp || Infinity)) * 1000).toISOString().slice(0, 10),
+                to: new Date(Math.max(...actArr.map((t) => t.timestamp || 0)) * 1000).toISOString().slice(0, 10),
+            } : null,
+            volumeByDay: (() => {
+                const byDay = {};
+                actArr.forEach((t) => {
+                    if (!t.timestamp)
+                        return;
+                    const day = new Date(t.timestamp * 1000).toISOString().slice(0, 10);
+                    byDay[day] = (byDay[day] || 0) + (Number(t.usdcSize) || 0);
+                });
+                return byDay;
+            })(),
+        },
+        fetchedAt: new Date().toISOString(),
+    };
+    return { domain, type: 'profile', structured, cleanContent };
+}
+// ── Event extractor ───────────────────────────────────────────────────────────
+async function extractEvent(slug, domain) {
+    try {
+        const events = await fetchJson(`https://gamma-api.polymarket.com/events?slug=${encodeURIComponent(slug)}&limit=1`);
+        if (Array.isArray(events) && events.length > 0) {
+            const event = events[0];
+            const markets = event.markets || [];
+            const structured = {
+                title: event.title || slug,
+                slug: event.slug,
+                volume: event.volume,
+                volume24hr: event.volume24hr,
+                endDate: event.endDate,
+                markets: markets.map((m) => ({
+                    question: m.question,
+                    outcomes: m.outcomes,
+                    outcomePrices: m.outcomePrices,
+                    volume: m.volume,
+                    volume24hr: m.volume24hr,
+                    endDate: m.endDate,
+                    bestBid: m.bestBid,
+                    bestAsk: m.bestAsk,
+                    lastTradePrice: m.lastTradePrice,
+                })),
+            };
+            const marketsMd = markets.map((m) => {
+                const outcomes = JSON.parse(m.outcomes || '[]');
+                const prices = JSON.parse(m.outcomePrices || '[]');
+                const priceStr = outcomes.map((o, i) => `${o}: **${fmtPct(prices[i] ?? 0)}**`).join(' | ');
+                const vol24 = m.volume24hr ? ` | Vol 24h: ${fmtVol(m.volume24hr)}` : '';
+                const endDate = m.endDate ? ` | Ends: ${fmtDate(m.endDate)}` : '';
+                return `- **${m.question}**\n  ${priceStr}${vol24}${endDate}`;
+            }).join('\n\n');
+            const totalVol24 = fmtVol(event.volume24hr || 0);
+            const totalVol = fmtVol(event.volume || 0);
+            const cleanContent = `# 📊 Polymarket: ${event.title || slug}
+
+**Volume (24h):** ${totalVol24} | **Total Volume:** ${totalVol} | **Ends:** ${fmtDate(event.endDate)}
+
+## Markets
+
+${marketsMd || '*No active markets found.*'}
+
+---
+*Source: [Polymarket](https://polymarket.com/event/${slug}) · Data via Polymarket Gamma API*`;
+            return { domain, type: 'event', structured, cleanContent };
+        }
+        // Fallback: keyword search
+        const markets = await fetchJson(`https://gamma-api.polymarket.com/markets?closed=false&limit=10&order=volume24hr&ascending=false&q=${encodeURIComponent(slug.replace(/-/g, ' '))}`);
+        if (Array.isArray(markets) && markets.length > 0) {
+            return buildPolymarketMarketList(markets, domain, `Search: ${slug}`);
+        }
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'Polymarket event fetch failed:', e instanceof Error ? e.message : e);
+    }
+    return null;
+}
+// ── Markets list ──────────────────────────────────────────────────────────────
+async function extractMarkets(domain) {
+    try {
+        const markets = await fetchJson('https://gamma-api.polymarket.com/markets?closed=false&limit=20&order=volume24hr&ascending=false');
+        if (Array.isArray(markets)) {
+            return buildPolymarketMarketList(markets, domain, 'Top Markets');
+        }
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'Polymarket markets fetch failed:', e instanceof Error ? e.message : e);
+    }
+    return null;
+}
+function buildPolymarketMarketList(markets, domain, title) {
+    const rows = markets.slice(0, 15).map((m) => {
+        const outcomes = (() => { try {
+            return JSON.parse(m.outcomes || '[]');
+        }
+        catch {
+            return [];
+        } })();
+        const prices = (() => { try {
+            return JSON.parse(m.outcomePrices || '[]');
+        }
+        catch {
+            return [];
+        } })();
+        const yesPrice = outcomes[0] ? fmtPct(prices[0] ?? 0) : '?%';
+        const vol24 = fmtVol(m.volume24hr || 0);
+        const end = m.endDate ? m.endDate.slice(0, 10) : '?';
+        return `| ${m.question} | ${yesPrice} | ${vol24} | ${end} |`;
+    }).join('\n');
+    const structured = {
+        markets: markets.slice(0, 15).map((m) => ({
+            question: m.question,
+            slug: m.slug,
+            outcomePrices: m.outcomePrices,
+            outcomes: m.outcomes,
+            volume24hr: m.volume24hr,
+            endDate: m.endDate,
+        })),
+        fetchedAt: new Date().toISOString(),
+    };
+    const cleanContent = `# 📊 Polymarket — ${title}
+
+| Question | Yes Price | Vol 24h | End Date |
+|----------|-----------|---------|----------|
+${rows}
+
+---
+*Source: [Polymarket](https://polymarket.com) · Data via Polymarket Gamma API*`;
+    return { domain, type: 'markets', structured, cleanContent };
+}

package/dist/ee/extractors/producthunt.d.ts

@@ -0,0 +1,2 @@
+import type { DomainExtractResult } from './types.js';
+export declare function productHuntExtractor(_html: string, _url: string): Promise<DomainExtractResult | null>;

package/dist/ee/extractors/producthunt.js

@@ -0,0 +1,88 @@
+import { simpleFetch } from '../../core/fetcher.js';
+import { stripHtml } from './shared.js';
+// ---------------------------------------------------------------------------
+// 31. Product Hunt extractor (RSS/Atom feed)
+// ---------------------------------------------------------------------------
+export async function productHuntExtractor(_html, _url) {
+    try {
+        // Fetch the public Atom feed — no auth required
+        const feedResult = await simpleFetch('https://www.producthunt.com/feed', 'WebPeel/0.17.1 (web data platform; https://webpeel.dev) Node.js', 15000, { Accept: 'application/xml, text/xml, */*' });
+        if (!feedResult?.html)
+            return null;
+        const xml = feedResult.html;
+        // Parse Atom entries (Product Hunt uses Atom, not RSS)
+        const entryMatches = [...xml.matchAll(/<entry>([\s\S]*?)<\/entry>/g)];
+        if (!entryMatches.length)
+            return null;
+        const products = [];
+        for (const match of entryMatches) {
+            const entry = match[1];
+            const titleMatch = entry.match(/<title>([\s\S]*?)<\/title>/);
+            const linkMatch = entry.match(/<link[^>]+href="([^"]+)"/);
+            const publishedMatch = entry.match(/<published>([\s\S]*?)<\/published>/);
+            const authorMatch = entry.match(/<name>([\s\S]*?)<\/name>/);
+            const contentMatch = entry.match(/<content[^>]*>([\s\S]*?)<\/content>/);
+            if (!titleMatch)
+                continue;
+            const title = stripHtml(titleMatch[1]).trim();
+            const link = linkMatch?.[1] || '';
+            const published = publishedMatch?.[1]?.trim() || '';
+            const author = authorMatch ? stripHtml(authorMatch[1]).trim() : '';
+            // Extract tagline from encoded HTML in <content>
+            // Content is HTML-encoded: &lt;p&gt;tagline&lt;/p&gt;...
+            let tagline = '';
+            let directLink = '';
+            if (contentMatch) {
+                const decoded = contentMatch[1]
+                    .replace(/&lt;/g, '<')
+                    .replace(/&gt;/g, '>')
+                    .replace(/&amp;/g, '&')
+                    .replace(/&quot;/g, '"')
+                    .replace(/&#39;/g, "'");
+                // First <p> is the tagline
+                const taglineMatch = decoded.match(/<p[^>]*>\s*([\s\S]*?)\s*<\/p>/);
+                if (taglineMatch) {
+                    tagline = stripHtml(taglineMatch[1]).trim();
+                }
+                // Extract direct product link (the "Link" href, not the discussion link)
+                const linkHrefMatch = decoded.match(/href="(https:\/\/www\.producthunt\.com\/r\/p\/[^"]+)"/);
+                directLink = linkHrefMatch?.[1] || link;
+            }
+            // Format published date nicely
+            let dateStr = '';
+            if (published) {
+                try {
+                    const d = new Date(published);
+                    dateStr = d.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' });
+                }
+                catch {
+                    dateStr = published.split('T')[0];
+                }
+            }
+            products.push({ title, link, published: dateStr, tagline, author, directLink });
+        }
+        if (!products.length)
+            return null;
+        // Build clean markdown output
+        const today = new Date().toLocaleDateString('en-US', { month: 'long', day: 'numeric', year: 'numeric' });
+        const productList = products.map((p, i) => {
+            const taglinePart = p.tagline ? ` — ${p.tagline}` : '';
+            const datePart = p.published ? `\n   📅 ${p.published}` : '';
+            const authorPart = p.author ? ` by ${p.author}` : '';
+            return `${i + 1}. **[${p.title}](${p.link})**${taglinePart}${datePart}${authorPart}`;
+        }).join('\n\n');
+        const structured = {
+            products,
+            total: products.length,
+            fetchedAt: new Date().toISOString(),
+            feedUrl: 'https://www.producthunt.com/feed',
+        };
+        const cleanContent = `# 🚀 Product Hunt — Featured Products\n\n*Fetched ${today} · ${products.length} products*\n\n${productList}\n\n---\n*Source: [Product Hunt Feed](https://www.producthunt.com/feed)*`;
+        return { domain: 'producthunt.com', type: 'feed', structured, cleanContent };
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'Product Hunt extractor failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}

package/dist/ee/extractors/pubmed.d.ts

@@ -0,0 +1,2 @@
+import type { DomainExtractResult } from './types.js';
+export declare function pubmedExtractor(_html: string, url: string): Promise<DomainExtractResult | null>;

package/dist/ee/extractors/pubmed.js

@@ -0,0 +1,162 @@
+import { simpleFetch } from '../../core/fetcher.js';
+import { stripHtml, fetchJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// PubMed extractor (NCBI E-utilities API — free, no key needed)
+// ---------------------------------------------------------------------------
+export async function pubmedExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const path = urlObj.pathname;
+    const domain = 'pubmed.ncbi.nlm.nih.gov';
+    // --- Article page: /XXXXXX/ or /XXXXXX ---
+    const pmidMatch = path.match(/^\/(\d+)\/?$/);
+    if (pmidMatch) {
+        const pmid = pmidMatch[1];
+        try {
+            // Fetch summary
+            const summaryUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=pubmed&id=${pmid}&retmode=json`;
+            const summaryData = await fetchJson(summaryUrl);
+            if (!summaryData?.result)
+                return null;
+            const result = summaryData.result;
+            const article = result[pmid];
+            if (!article)
+                return null;
+            // Fetch abstract via efetch
+            let abstract = '';
+            try {
+                const efetchUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=pubmed&id=${pmid}&retmode=xml&rettype=abstract`;
+                const efetchResult = await simpleFetch(efetchUrl, 'WebPeel/0.21', 15000, { Accept: 'application/xml' });
+                if (efetchResult?.html) {
+                    const abstractMatch = efetchResult.html.match(/<AbstractText[^>]*>([\s\S]*?)<\/AbstractText>/g);
+                    if (abstractMatch) {
+                        abstract = abstractMatch.map((m) => {
+                            const labelMatch = m.match(/Label="([^"]+)"/);
+                            const textMatch = m.match(/<AbstractText[^>]*>([\s\S]*?)<\/AbstractText>/);
+                            const text = textMatch ? stripHtml(textMatch[1]).trim() : '';
+                            return labelMatch ? `**${labelMatch[1]}:** ${text}` : text;
+                        }).join('\n\n');
+                    }
+                }
+            }
+            catch { /* abstract is optional */ }
+            const authors = article.authors || [];
+            const authorNames = authors.filter(a => a.authtype !== 'CollectiveName').map(a => a.name);
+            const authorLine = authorNames.length <= 6
+                ? authorNames.join(', ')
+                : `${authorNames.slice(0, 6).join(', ')} et al.`;
+            const doi = article.elocationid?.replace(/^doi:\s*/i, '') || null;
+            const pubDate = article.pubdate || '?';
+            const journal = article.source || '?';
+            const volume = article.volume ? ` ${article.volume}` : '';
+            const issue = article.issue ? `(${article.issue})` : '';
+            const pages = article.pages ? `:${article.pages}` : '';
+            const structured = {
+                pmid,
+                title: article.title,
+                authors: authorNames,
+                journal,
+                pubDate,
+                volume: article.volume,
+                issue: article.issue,
+                pages: article.pages,
+                doi,
+                abstract: abstract || undefined,
+                url: `https://pubmed.ncbi.nlm.nih.gov/${pmid}/`,
+            };
+            const lines = [
+                `# 🧬 ${article.title}`,
+                '',
+                `**Authors:** ${authorLine}`,
+                `**Journal:** *${journal}*${volume}${issue}${pages} (${pubDate})`,
+                `**PMID:** ${pmid}`,
+            ];
+            if (doi)
+                lines.push(`**DOI:** [${doi}](https://doi.org/${doi})`);
+            if (abstract) {
+                lines.push('', '## Abstract', '', abstract);
+            }
+            lines.push('', `**Link:** [PubMed](https://pubmed.ncbi.nlm.nih.gov/${pmid}/)`);
+            return {
+                domain,
+                type: 'article',
+                structured,
+                cleanContent: lines.join('\n'),
+            };
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'PubMed article API failed:', e instanceof Error ? e.message : e);
+            return null;
+        }
+    }
+    // --- Search page: /?term=... or /?query=... ---
+    const term = urlObj.searchParams.get('term') || urlObj.searchParams.get('query');
+    if (term) {
+        try {
+            // Step 1: search for IDs
+            const searchUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=pubmed&term=${encodeURIComponent(term)}&retmode=json&retmax=10`;
+            const searchData = await fetchJson(searchUrl);
+            if (!searchData?.esearchresult)
+                return null;
+            const esearch = searchData.esearchresult;
+            const ids = esearch.idlist || [];
+            const total = parseInt(esearch.count || '0', 10);
+            if (ids.length === 0) {
+                return {
+                    domain,
+                    type: 'search',
+                    structured: { query: term, total: 0, articles: [] },
+                    cleanContent: `# 🔍 PubMed — "${term}"\n\n*No results found.*`,
+                };
+            }
+            // Step 2: fetch summaries
+            const summaryUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=pubmed&id=${ids.join(',')}&retmode=json`;
+            const summaryData = await fetchJson(summaryUrl);
+            if (!summaryData?.result)
+                return null;
+            const result = summaryData.result;
+            const articles = (result.uids || ids).map((id) => {
+                const a = result[id];
+                if (!a)
+                    return null;
+                const authors = a.authors || [];
+                return {
+                    pmid: id,
+                    title: a.title,
+                    journal: a.source,
+                    pubDate: a.pubdate,
+                    authors: authors.map(x => x.name),
+                    doi: a.elocationid?.replace(/^doi:\s*/i, '') || null,
+                };
+            }).filter(Boolean);
+            const rows = articles.map((a, i) => {
+                const authorLine = a.authors.length === 0 ? '—'
+                    : a.authors.length === 1 ? a.authors[0]
+                        : `${a.authors[0]} et al.`;
+                const link = `https://pubmed.ncbi.nlm.nih.gov/${a.pmid}/`;
+                return `| ${i + 1} | [${a.title}](${link}) | *${a.journal}* | ${a.pubDate} | ${authorLine} |`;
+            }).join('\n');
+            const cleanContent = [
+                `# 🔍 PubMed — "${term}"`,
+                '',
+                '| # | Article | Journal | Date | Authors |',
+                '|---|---------|---------|------|---------|',
+                rows,
+                '',
+                `*Source: NCBI PubMed E-utilities · Total results: ${total.toLocaleString()}*`,
+            ].join('\n');
+            return {
+                domain,
+                type: 'search',
+                structured: { query: term, total, articles },
+                cleanContent,
+            };
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'PubMed search API failed:', e instanceof Error ? e.message : e);
+            return null;
+        }
+    }
+    return null;
+}

package/dist/ee/extractors/pypi.d.ts

@@ -0,0 +1,2 @@
+import type { DomainExtractResult } from './types.js';
+export declare function pypiExtractor(_html: string, url: string): Promise<DomainExtractResult | null>;