@iflow-mcp/jakeliume-webpeel 0.22.0

package/dist/ee/extractors/twitter.js

@@ -0,0 +1,327 @@
+import { tryParseJson, stripHtml, fetchJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// 1. Twitter / X extractor
+// ---------------------------------------------------------------------------
+/** Recursively search an object for a value matching predicate (BFS). */
+function deepFind(obj, predicate, depth = 0) {
+    if (depth > 12 || obj === null || typeof obj !== 'object')
+        return null;
+    if (predicate(obj))
+        return obj;
+    for (const val of Object.values(obj)) {
+        const found = deepFind(val, predicate, depth + 1);
+        if (found !== null)
+            return found;
+    }
+    return null;
+}
+/** Detect tweet type from __NEXT_DATA__ and extract all tweet data. */
+function parseTweetFromNextData(nextData) {
+    // Walk the tree to find a tweet_results.result structure
+    const tweetResult = deepFind(nextData, (v) => v?.tweet_results?.result?.legacy?.full_text !== undefined);
+    if (!tweetResult)
+        return null;
+    const result = tweetResult.tweet_results.result;
+    return parseTweetResult(result);
+}
+function parseTweetResult(result) {
+    const legacy = result?.legacy;
+    if (!legacy)
+        return null;
+    const userLegacy = result?.core?.user_results?.result?.legacy ||
+        result?.user_results?.result?.legacy;
+    const author = {
+        name: userLegacy?.name || '',
+        handle: '@' + (userLegacy?.screen_name || ''),
+        verified: userLegacy?.verified || result?.core?.user_results?.result?.is_blue_verified || false,
+    };
+    const metrics = {
+        likes: legacy.favorite_count ?? 0,
+        retweets: legacy.retweet_count ?? 0,
+        replies: legacy.reply_count ?? 0,
+        views: Number(result?.views?.count ?? 0),
+    };
+    // Media
+    const mediaItems = [];
+    const mediaEntities = legacy.extended_entities?.media || legacy.entities?.media || [];
+    for (const m of mediaEntities) {
+        if (m.media_url_https)
+            mediaItems.push(m.media_url_https);
+    }
+    // Quoted tweet
+    let quotedTweet = null;
+    if (result.quoted_status_result) {
+        const qLegacy = result.quoted_status_result?.result?.legacy;
+        const qUserLegacy = result.quoted_status_result?.result?.core?.user_results?.result?.legacy;
+        if (qLegacy) {
+            quotedTweet = {
+                text: qLegacy.full_text || qLegacy.text || '',
+                author: {
+                    name: qUserLegacy?.name || '',
+                    handle: '@' + (qUserLegacy?.screen_name || ''),
+                },
+                timestamp: qLegacy.created_at ? new Date(qLegacy.created_at).toISOString() : undefined,
+            };
+        }
+    }
+    return {
+        author,
+        text: legacy.full_text || legacy.text || '',
+        timestamp: legacy.created_at ? new Date(legacy.created_at).toISOString() : undefined,
+        metrics,
+        media: mediaItems,
+        quotedTweet,
+    };
+}
+export async function twitterExtractor(html, url) {
+    const urlObj = new URL(url);
+    const pathParts = urlObj.pathname.split('/').filter(Boolean);
+    const isTweet = pathParts.includes('status');
+    const type = isTweet ? 'tweet' : 'profile';
+    const domain = 'twitter.com';
+    // --- Try FxTwitter API first (works from datacenter IPs, no auth needed) ---
+    const username = pathParts[0] || '';
+    if (isTweet) {
+        const statusId = pathParts[pathParts.indexOf('status') + 1];
+        if (statusId && username) {
+            try {
+                const fxUrl = `https://api.fxtwitter.com/${username}/status/${statusId}`;
+                const fxData = await fetchJson(fxUrl);
+                if (fxData && fxData.code === 200 && fxData.tweet) {
+                    const t = fxData.tweet;
+                    const structured = {
+                        author: {
+                            name: t.author?.name || '',
+                            handle: '@' + (t.author?.screen_name || ''),
+                            verified: t.author?.verified || false,
+                        },
+                        text: t.text || '',
+                        timestamp: t.created_at ? new Date(t.created_at).toISOString() : undefined,
+                        metrics: {
+                            likes: t.likes ?? 0,
+                            retweets: t.retweets ?? 0,
+                            replies: t.replies ?? 0,
+                            views: t.views ?? 0,
+                        },
+                        media: (t.media?.all || []).map((m) => m.url).filter(Boolean),
+                        quotedTweet: t.quote ? {
+                            text: t.quote.text || '',
+                            author: { name: t.quote.author?.name || '', handle: '@' + (t.quote.author?.screen_name || '') },
+                        } : null,
+                        source: 'fxtwitter',
+                    };
+                    const authorLine = `**${structured.author.name}** (${structured.author.handle})`;
+                    const timeLine = structured.timestamp ? `\n*${structured.timestamp}*` : '';
+                    const metricsLine = `\n\n💬 ${structured.metrics.replies}  🔁 ${structured.metrics.retweets}  ❤️ ${structured.metrics.likes}${structured.metrics.views ? `  👁 ${structured.metrics.views}` : ''}`;
+                    const mediaLine = structured.media.length ? `\n\n📷 Media: ${structured.media.join(', ')}` : '';
+                    const quotedLine = structured.quotedTweet
+                        ? `\n\n> **Quoted tweet by ${structured.quotedTweet.author?.name || 'unknown'}:** ${structured.quotedTweet.text}`
+                        : '';
+                    const cleanContent = `## 🐦 Tweet by ${authorLine}${timeLine}\n\n${structured.text}${quotedLine}${metricsLine}${mediaLine}`;
+                    return { domain, type, structured, cleanContent };
+                }
+            }
+            catch (e) {
+                if (process.env.DEBUG)
+                    console.debug('[webpeel]', 'FxTwitter API failed:', e instanceof Error ? e.message : e);
+            }
+        }
+    }
+    // --- Try FxTwitter for profiles ---
+    if (!isTweet && username) {
+        try {
+            const fxUrl = `https://api.fxtwitter.com/${username}`;
+            const fxData = await fetchJson(fxUrl);
+            if (fxData && fxData.code === 200 && fxData.user) {
+                const u = fxData.user;
+                const structured = {
+                    title: `${u.name || ''} (@${u.screen_name || ''}) on X/Twitter`,
+                    name: u.name || '',
+                    handle: '@' + (u.screen_name || ''),
+                    bio: u.description || '',
+                    followers: u.followers ?? 0,
+                    following: u.following ?? 0,
+                    tweets: u.tweets ?? 0,
+                    likes: u.likes ?? 0,
+                    verified: u.verification?.verified || false,
+                    location: u.location || '',
+                    created: u.joined || undefined,
+                    avatarUrl: u.avatar_url || null,
+                    bannerUrl: u.banner_url || null,
+                    website: (typeof u.website === 'object' ? u.website?.url : u.website) || null,
+                    source: 'fxtwitter',
+                };
+                // Try to fetch recent tweets from Twitter's public syndication endpoint
+                // NOTE: simpleFetch sends too many Sec-* headers that trigger 429. Use https directly.
+                let recentTweets = '';
+                try {
+                    const { default: httpsModule } = await import('https');
+                    const syndicationHtml = await new Promise((resolve, reject) => {
+                        const req = httpsModule.request({
+                            hostname: 'syndication.twitter.com',
+                            path: `/srv/timeline-profile/screen-name/${u.screen_name}`,
+                            method: 'GET',
+                            headers: {
+                                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                                'Accept-Language': 'en-US,en;q=0.9',
+                            },
+                        }, (res) => {
+                            if (res.statusCode !== 200) {
+                                reject(new Error(`HTTP ${res.statusCode}`));
+                                res.resume();
+                                return;
+                            }
+                            let body = '';
+                            res.on('data', (chunk) => body += chunk.toString());
+                            res.on('end', () => resolve(body));
+                        });
+                        req.on('error', reject);
+                        setTimeout(() => req.destroy(new Error('timeout')), 12000);
+                        req.end();
+                    });
+                    if (syndicationHtml) {
+                        // Parse __NEXT_DATA__ JSON from the syndication page for rich tweet data
+                        const nextDataMatch = syndicationHtml.match(/<script id="__NEXT_DATA__"[^>]*>([\s\S]*?)<\/script>/i);
+                        if (nextDataMatch) {
+                            const nextData = tryParseJson(nextDataMatch[1]);
+                            const entries = nextData?.props?.pageProps?.timeline?.entries || [];
+                            const tweetSections = [];
+                            for (const entry of entries) {
+                                if (tweetSections.length >= 8)
+                                    break;
+                                const tweet = entry?.content?.tweet;
+                                if (!tweet?.full_text)
+                                    continue;
+                                const text = tweet.full_text.replace(/\\n/g, '\n').replace(/\\"/g, '"').trim();
+                                // Skip retweets and pure-URL-only tweets without media
+                                if (text.startsWith('RT @'))
+                                    continue;
+                                const media = tweet.extended_entities?.media || tweet.entities?.media || [];
+                                const isUrlOnly = /^https?:\/\/t\.co\/\S+$/.test(text.trim()) || /^https?:\/\/t\.co\/\S+\s*$/.test(text.trim());
+                                if (isUrlOnly && media.length === 0)
+                                    continue;
+                                // Format date
+                                const dateStr = tweet.created_at ? (() => {
+                                    try {
+                                        return new Date(tweet.created_at).toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
+                                    }
+                                    catch {
+                                        return tweet.created_at;
+                                    }
+                                })() : '';
+                                const likes = tweet.favorite_count ?? 0;
+                                const retweets = tweet.retweet_count ?? 0;
+                                const replies = tweet.reply_count ?? 0;
+                                const fmtNum = (n) => n >= 1000000 ? (n / 1000000).toFixed(1) + 'M' : n >= 1000 ? (n / 1000).toFixed(1) + 'K' : String(n);
+                                const mediaLine = media.length > 0 ? `\n📷 ${media.map((m) => m.media_url_https || m.media_url).filter(Boolean).join(', ')}` : '';
+                                // Clean t.co URLs from text when they have real media
+                                const cleanText = media.length > 0 ? text.replace(/https?:\/\/t\.co\/\S+/g, '').trim() : text;
+                                tweetSections.push(`### ${dateStr}\n${cleanText}${mediaLine}\n♻️ ${fmtNum(retweets)} | ❤️ ${fmtNum(likes)} | 💬 ${fmtNum(replies)}`);
+                            }
+                            if (tweetSections.length > 0) {
+                                recentTweets = '\n\n## Recent Tweets\n\n' + tweetSections.join('\n\n---\n\n');
+                            }
+                        }
+                        else {
+                            // Fallback: simple regex extraction without metrics
+                            const tweetMatches = [...syndicationHtml.matchAll(/"full_text":"((?:[^"\\]|\\.)*)"/g)];
+                            const tweets = tweetMatches
+                                .slice(0, 5)
+                                .map(m => m[1].replace(/\\n/g, ' ').replace(/\\"/g, '"').trim())
+                                .filter(t => t.length > 10 && !t.startsWith('RT @'));
+                            if (tweets.length > 0) {
+                                recentTweets = '\n\n## Recent Tweets\n\n' + tweets.map(t => `> ${t}`).join('\n\n');
+                            }
+                        }
+                    }
+                }
+                catch { /* syndication optional */ }
+                const websiteLine = structured.website ? `\n🌐 ${structured.website}` : '';
+                const joinedLine = structured.created ? `\n📅 Joined: ${structured.created}` : '';
+                const likesLine = structured.likes ? `  |  ❤️ Likes: ${structured.likes?.toLocaleString() || 0}` : '';
+                const cleanContent = `# @${(structured.handle || '').replace('@', '')} on X/Twitter\n\n**${structured.name}**${structured.verified ? ' ✓' : ''}\n\n${structured.bio || ''}\n\n📍 ${structured.location || 'N/A'}${websiteLine}${joinedLine}\n👥 Followers: ${structured.followers?.toLocaleString() || 0} | Following: ${structured.following?.toLocaleString() || 0} | Tweets: ${structured.tweets?.toLocaleString() || 0}${likesLine}${recentTweets}`;
+                return { domain, type: 'profile', structured, cleanContent };
+            }
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'FxTwitter profile API failed:', e instanceof Error ? e.message : e);
+        }
+    }
+    // --- Try __NEXT_DATA__ JSON (SSR data) ---
+    const nextDataMatch = html.match(/<script id="__NEXT_DATA__"[^>]*>([\s\S]*?)<\/script>/i);
+    let structured = null;
+    if (nextDataMatch) {
+        const nextData = tryParseJson(nextDataMatch[1]);
+        if (nextData) {
+            if (isTweet) {
+                const tweetData = parseTweetFromNextData(nextData);
+                if (tweetData) {
+                    structured = tweetData;
+                }
+            }
+            else {
+                // Profile page — extract user info
+                const userResult = deepFind(nextData, (v) => v?.user_results?.result?.legacy?.screen_name);
+                if (userResult) {
+                    const uLegacy = userResult.user_results.result.legacy;
+                    structured = {
+                        name: uLegacy.name || '',
+                        handle: '@' + (uLegacy.screen_name || ''),
+                        bio: uLegacy.description || '',
+                        followers: uLegacy.followers_count ?? 0,
+                        following: uLegacy.friends_count ?? 0,
+                        tweets: uLegacy.statuses_count ?? 0,
+                        verified: userResult.user_results.result.is_blue_verified || uLegacy.verified || false,
+                        location: uLegacy.location || '',
+                        created: uLegacy.created_at ? new Date(uLegacy.created_at).toISOString() : undefined,
+                    };
+                }
+            }
+        }
+    }
+    // --- Fallback: parse DOM for tweet text if __NEXT_DATA__ parsing failed ---
+    if (!structured && isTweet) {
+        // Try to extract from og: tags or article body
+        const ogDescMatch = html.match(/<meta[^>]+property="og:description"[^>]+content="([^"]+)"/i);
+        const ogTitleMatch = html.match(/<meta[^>]+property="og:title"[^>]+content="([^"]+)"/i);
+        if (ogDescMatch || ogTitleMatch) {
+            const authorRaw = (ogTitleMatch?.[1] || '').replace(' on X', '').replace(' on Twitter', '').trim();
+            const text = ogDescMatch?.[1] ? decodeURIComponent(ogDescMatch[1].replace(/&#39;/g, "'").replace(/&amp;/g, '&')) : '';
+            structured = {
+                author: { name: authorRaw, handle: '', verified: false },
+                text: stripHtml(text),
+                timestamp: undefined,
+                metrics: { likes: 0, retweets: 0, replies: 0, views: 0 },
+                media: [],
+                quotedTweet: null,
+            };
+        }
+    }
+    if (!structured)
+        return null;
+    // Build clean markdown
+    let cleanContent;
+    if (type === 'tweet') {
+        const s = structured;
+        const authorLine = s.author?.handle
+            ? `**${s.author.name}** (${s.author.handle})`
+            : `**${s.author?.name || 'Unknown'}**`;
+        const timeLine = s.timestamp ? `\n*${s.timestamp}*` : '';
+        const metricsLine = s.metrics
+            ? `\n\n💬 ${s.metrics.replies}  🔁 ${s.metrics.retweets}  ❤️ ${s.metrics.likes}${s.metrics.views ? `  👁 ${s.metrics.views}` : ''}`
+            : '';
+        const mediaLine = s.media?.length ? `\n\n📷 Media: ${s.media.join(', ')}` : '';
+        const quotedLine = s.quotedTweet
+            ? `\n\n> **Quoted tweet by ${s.quotedTweet.author?.name || 'unknown'}:** ${s.quotedTweet.text}`
+            : '';
+        const threadLine = s.thread?.length ? '\n\n**Thread:**\n' + s.thread.map((t, i) => `${i + 2}. ${t.text}`).join('\n') : '';
+        cleanContent = `## 🐦 Tweet by ${authorLine}${timeLine}\n\n${s.text}${quotedLine}${threadLine}${metricsLine}${mediaLine}`;
+    }
+    else {
+        const s = structured;
+        cleanContent = `## 🐦 @${(s.handle || '').replace('@', '')} on X/Twitter\n\n**${s.name}**\n${s.bio || ''}\n\n📍 ${s.location || 'N/A'}  |  👥 ${s.followers?.toLocaleString() || 0} followers  |  Following: ${s.following?.toLocaleString() || 0}  |  Tweets: ${s.tweets?.toLocaleString() || 0}`;
+    }
+    return { domain, type, structured, cleanContent };
+}

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

@@ -0,0 +1,14 @@
+export interface DomainExtractResult {
+    /** Canonical domain name (e.g. 'twitter.com') */
+    domain: string;
+    /** Page type within the domain (e.g. 'tweet', 'thread', 'repo', 'issue') */
+    type: string;
+    /** Domain-specific structured data */
+    structured: Record<string, any>;
+    /** Clean markdown representation of the content */
+    cleanContent: string;
+    /** Raw HTML size in characters (from the actual HTML page fetched by the extractor) */
+    rawHtmlSize?: number;
+}
+/** An extractor receives the raw HTML and original URL, may make API calls. */
+export type DomainExtractor = (html: string, url: string) => Promise<DomainExtractResult | null>;

package/dist/ee/extractors/types.js

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

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

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

package/dist/ee/extractors/walmart.js

@@ -0,0 +1,50 @@
+import { fetchJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// 11. Walmart extractor (Walmart frontend search API)
+// ---------------------------------------------------------------------------
+export async function walmartExtractor(_html, url) {
+    // Extract item ID from URL patterns:
+    // /ip/Product-Name/1234567 or /ip/1234567
+    const itemMatch = url.match(/\/ip\/(?:.*\/)?(\d+)/);
+    if (!itemMatch)
+        return null;
+    const itemId = itemMatch[1];
+    // Try Walmart's BE API (used by their frontend, sometimes accessible)
+    const apiUrl = `https://www.walmart.com/orchestra/snb/graphql/Search?query=${itemId}&page=1&affinityOverride=default&limit=1`;
+    try {
+        const response = await fetchJson(apiUrl, {
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+            'Accept': 'application/json',
+            'Referer': 'https://www.walmart.com/',
+        });
+        if (response?.data?.search?.searchResult?.itemStacks?.[0]?.items?.[0]) {
+            const item = response.data.search.searchResult.itemStacks[0].items[0];
+            const lines = [];
+            lines.push(`# ${item.name}`);
+            if (item.priceInfo?.currentPrice?.price) {
+                lines.push(`**Price:** $${item.priceInfo.currentPrice.price}`);
+            }
+            if (item.averageRating) {
+                lines.push(`**Rating:** ${item.averageRating}/5 (${item.numberOfReviews || 0} reviews)`);
+            }
+            if (item.shortDescription)
+                lines.push(item.shortDescription);
+            const structured = {
+                name: item.name,
+                price: item.priceInfo?.currentPrice?.price,
+                rating: item.averageRating,
+                reviewCount: item.numberOfReviews,
+                image: item.imageInfo?.thumbnailUrl,
+                itemId: itemId,
+                inStock: item.availabilityStatusV2?.value === 'IN_STOCK',
+            };
+            return { domain: 'walmart.com', type: 'product', structured, cleanContent: lines.join('\n') };
+        }
+        return null;
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'Walmart API failed:', e instanceof Error ? e.message : e);
+        return null; // API not accessible, fall through to other methods
+    }
+}

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

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

package/dist/ee/extractors/weather.js

@@ -0,0 +1,133 @@
+import { fetchJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// 39. Weather extractor — Open-Meteo free API (no key required)
+// ---------------------------------------------------------------------------
+// Weather code descriptions (WMO)
+const WMO_CODES = {
+    0: 'Clear sky', 1: 'Mainly clear', 2: 'Partly cloudy', 3: 'Overcast',
+    45: 'Foggy', 48: 'Icy fog',
+    51: 'Light drizzle', 53: 'Moderate drizzle', 55: 'Dense drizzle',
+    61: 'Slight rain', 63: 'Moderate rain', 65: 'Heavy rain',
+    71: 'Slight snow', 73: 'Moderate snow', 75: 'Heavy snow',
+    80: 'Slight showers', 81: 'Moderate showers', 82: 'Violent showers',
+    85: 'Slight snow showers', 86: 'Heavy snow showers',
+    95: 'Thunderstorm', 96: 'Thunderstorm w/ hail', 99: 'Thunderstorm w/ heavy hail',
+};
+const WEATHER_ICONS = {
+    0: '☀️', 1: '🌤️', 2: '⛅', 3: '☁️',
+    45: '🌫️', 48: '🌫️',
+    51: '🌦️', 53: '🌦️', 55: '🌧️',
+    61: '🌦️', 63: '🌧️', 65: '🌧️',
+    71: '🌨️', 73: '❄️', 75: '❄️',
+    80: '🌦️', 81: '🌧️', 82: '⛈️',
+    85: '🌨️', 86: '❄️',
+    95: '⛈️', 96: '⛈️', 99: '⛈️',
+};
+// Default city coordinates for common weather sites
+const DEFAULT_CITY = { name: 'New York City', lat: 40.7128, lon: -74.0060, tz: 'America/New_York' };
+export async function weatherExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const hostname = urlObj.hostname;
+    // Determine lat/lon from URL params (for open-meteo.com direct API links)
+    let lat = null;
+    let lon = null;
+    let cityName = DEFAULT_CITY.name;
+    let timezone = DEFAULT_CITY.tz;
+    if (hostname.includes('open-meteo.com')) {
+        const latParam = urlObj.searchParams.get('latitude');
+        const lonParam = urlObj.searchParams.get('longitude');
+        const tzParam = urlObj.searchParams.get('timezone');
+        if (latParam && lonParam) {
+            lat = parseFloat(latParam);
+            lon = parseFloat(lonParam);
+            cityName = `${lat.toFixed(2)}°N, ${lon.toFixed(2)}°E`;
+            if (tzParam)
+                timezone = tzParam;
+        }
+    }
+    // For weather.com / accuweather: try to extract city from URL path
+    if (hostname.includes('weather.com') || hostname.includes('accuweather.com')) {
+        const path = urlObj.pathname;
+        // weather.com: /weather/today/l/40.71,-74.01:4:US or similar
+        const coordMatch = path.match(/\/l\/(-?\d+\.?\d*),(-?\d+\.?\d*)/);
+        if (coordMatch) {
+            lat = parseFloat(coordMatch[1]);
+            lon = parseFloat(coordMatch[2]);
+            cityName = `${lat.toFixed(2)}, ${lon.toFixed(2)}`;
+        }
+    }
+    // Default to NYC if no coords found
+    if (lat == null || lon == null) {
+        lat = DEFAULT_CITY.lat;
+        lon = DEFAULT_CITY.lon;
+        cityName = DEFAULT_CITY.name;
+        timezone = DEFAULT_CITY.tz;
+    }
+    try {
+        const apiUrl = `https://api.open-meteo.com/v1/forecast?latitude=${lat}&longitude=${lon}&current=temperature_2m,relative_humidity_2m,wind_speed_10m,weather_code&daily=temperature_2m_max,temperature_2m_min,precipitation_sum,weather_code&timezone=${encodeURIComponent(timezone)}&forecast_days=7`;
+        const data = await fetchJson(apiUrl);
+        if (!data || data.error)
+            return null;
+        const current = data.current || {};
+        const daily = data.daily || {};
+        const tempC = current.temperature_2m;
+        const tempF = tempC != null ? Math.round(tempC * 9 / 5 + 32) : null;
+        const humidity = current.relative_humidity_2m;
+        const wind = current.wind_speed_10m;
+        const wCode = current.weather_code;
+        const condition = WMO_CODES[wCode] || 'Unknown';
+        const icon = WEATHER_ICONS[wCode] || '🌡️';
+        let cleanContent = `# ${icon} Weather Forecast — ${cityName}\n\n`;
+        if (tempC != null) {
+            cleanContent += `**Current:** ${tempC}°C (${tempF}°F)`;
+            if (wind != null)
+                cleanContent += `, Wind: ${wind} km/h`;
+            if (humidity != null)
+                cleanContent += `, Humidity: ${humidity}%`;
+            cleanContent += `, ${condition}\n\n`;
+        }
+        if (daily.time?.length) {
+            cleanContent += `| Date | Low | High | Precip | Condition |\n`;
+            cleanContent += `|------|-----|------|--------|----------|\n`;
+            for (let i = 0; i < Math.min(daily.time.length, 7); i++) {
+                const date = daily.time[i];
+                const low = daily.temperature_2m_min?.[i];
+                const high = daily.temperature_2m_max?.[i];
+                const precip = daily.precipitation_sum?.[i];
+                const dayCode = daily.weather_code?.[i];
+                const dayIcon = WEATHER_ICONS[dayCode] || '';
+                const dayCondition = WMO_CODES[dayCode] || '';
+                const lowStr = low != null ? `${low}°C` : '?';
+                const highStr = high != null ? `${high}°C` : '?';
+                const precipStr = precip != null ? `${precip}mm` : '0mm';
+                cleanContent += `| ${date} | ${lowStr} | ${highStr} | ${precipStr} | ${dayIcon} ${dayCondition} |\n`;
+            }
+        }
+        cleanContent += `\n---\n*Source: Open-Meteo API · Coordinates: ${lat}, ${lon} · Updated: ${data.current?.time || new Date().toISOString()}*`;
+        return {
+            domain: 'open-meteo.com',
+            type: 'forecast',
+            structured: {
+                city: cityName,
+                lat,
+                lon,
+                timezone,
+                current: {
+                    temperature_c: tempC,
+                    temperature_f: tempF,
+                    humidity,
+                    wind_speed_kmh: wind,
+                    condition,
+                    weather_code: wCode,
+                },
+                daily: daily,
+            },
+            cleanContent,
+        };
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'Weather API failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}

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

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