@iflow-mcp/jakeliume-webpeel 0.22.0

package/dist/ee/extractors/espn.js

@@ -0,0 +1,260 @@
+import { fetchJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// 36. ESPN extractor — live scores, standings, schedules via ESPN public API
+// ---------------------------------------------------------------------------
+/** Map ESPN URL path prefixes to sport/league identifiers for the API. */
+function matchESPN(url) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    if (!u.hostname.includes('espn.com'))
+        return null;
+    const path = u.pathname.toLowerCase();
+    // Map URL path prefixes to [sport, league]
+    const sportMap = {
+        '/nba': ['basketball', 'nba'],
+        '/wnba': ['basketball', 'wnba'],
+        '/nfl': ['football', 'nfl'],
+        '/mlb': ['baseball', 'mlb'],
+        '/nhl': ['hockey', 'nhl'],
+        '/college-football': ['football', 'college-football'],
+        '/mens-college-basketball': ['basketball', 'mens-college-basketball'],
+        '/womens-college-basketball': ['basketball', 'womens-college-basketball'],
+        '/soccer': ['soccer', 'eng.1'],
+        '/mma': ['mma', 'ufc'],
+    };
+    for (const [prefix, [sport, league]] of Object.entries(sportMap)) {
+        if (path.startsWith(prefix)) {
+            // Override soccer league if explicitly in URL path (e.g. /soccer/scoreboard/_/league/usa.1)
+            let resolvedLeague = league;
+            if (sport === 'soccer') {
+                const leagueMatch = path.match(/\/league\/([^/?#]+)/);
+                if (leagueMatch)
+                    resolvedLeague = leagueMatch[1];
+            }
+            if (path.includes('standings'))
+                return { sport, league: resolvedLeague, type: 'standings' };
+            if (path.includes('/team/') || path.includes('/teams/')) {
+                const nameMatch = path.split('/name/')[1]?.split('/')[0];
+                return { sport, league: resolvedLeague, type: 'team', param: nameMatch };
+            }
+            if (path.includes('scores') || path.includes('scoreboard'))
+                return { sport, league: resolvedLeague, type: 'scoreboard' };
+            return { sport, league: resolvedLeague, type: 'scoreboard' }; // default to scoreboard
+        }
+    }
+    // Unknown path (e.g. /about, /fantasy, /watch) — return null so pipeline
+    // falls through to browser rendering instead of showing wrong sport data.
+    // Only the root path / is treated as NBA scoreboard.
+    if (path === '/' || path === '') {
+        return { sport: 'basketball', league: 'nba', type: 'scoreboard' };
+    }
+    return null;
+}
+/** Sport emoji mapping. */
+function espnSportEmoji(sport, league) {
+    if (league === 'nba' || league === 'wnba')
+        return '🏀';
+    if (sport === 'football')
+        return '🏈';
+    if (sport === 'baseball')
+        return '⚾';
+    if (sport === 'hockey')
+        return '🏒';
+    if (sport === 'soccer')
+        return '⚽';
+    if (sport === 'mma' || league === 'ufc')
+        return '🥊';
+    return '🏆';
+}
+/** Format a UTC ISO date string to "7:30 PM ET" style. */
+function fmtEspnTime(isoDate) {
+    try {
+        const d = new Date(isoDate);
+        return d.toLocaleTimeString('en-US', {
+            timeZone: 'America/New_York',
+            hour: 'numeric',
+            minute: '2-digit',
+            hour12: true,
+        }) + ' ET';
+    }
+    catch {
+        return isoDate;
+    }
+}
+/** Format today's date nicely: "March 18, 2026". */
+function fmtTodayESPN() {
+    return new Date().toLocaleDateString('en-US', {
+        timeZone: 'America/New_York',
+        month: 'long',
+        day: 'numeric',
+        year: 'numeric',
+    });
+}
+async function fetchEspnScoreboard(sport, league) {
+    try {
+        const apiUrl = `https://site.api.espn.com/apis/site/v2/sports/${sport}/${league}/scoreboard`;
+        const data = await fetchJson(apiUrl);
+        const events = data?.events || [];
+        const emoji = espnSportEmoji(sport, league);
+        const leagueName = data?.leagues?.[0]?.name || league.toUpperCase();
+        const today = fmtTodayESPN();
+        if (events.length === 0) {
+            return `# ${emoji} ${leagueName} Scoreboard — ${today}\n\n*No games scheduled today.*`;
+        }
+        const rows = events.map((e) => {
+            const comp = e.competitions?.[0] || {};
+            const status = comp.status?.type || {};
+            const competitors = comp.competitors || [];
+            // Away team first, home team second (standard display)
+            const away = competitors.find((c) => c.homeAway === 'away') || competitors[0];
+            const home = competitors.find((c) => c.homeAway === 'home') || competitors[1];
+            const awayName = away?.team?.displayName || away?.team?.name || '?';
+            const homeName = home?.team?.displayName || home?.team?.name || '?';
+            const gameLabel = `${awayName} at ${homeName}`;
+            let scoreStr = '-';
+            let statusStr = '';
+            const state = status.state || 'pre';
+            const description = status.description || 'Scheduled';
+            if (state === 'pre') {
+                scoreStr = '-';
+                statusStr = fmtEspnTime(comp.startDate || e.date || '');
+            }
+            else if (state === 'in') {
+                const awayScore = away?.score ?? '0';
+                const homeScore = home?.score ?? '0';
+                const awayAbbr = away?.team?.abbreviation || '?';
+                const homeAbbr = home?.team?.abbreviation || '?';
+                scoreStr = `${awayAbbr} ${awayScore}, ${homeAbbr} ${homeScore}`;
+                const period = comp.status?.period ?? '';
+                const clock = comp.status?.displayClock ?? '';
+                statusStr = period && clock ? `Q${period} ${clock}` : 'Live';
+            }
+            else {
+                const awayScore = away?.score ?? '0';
+                const homeScore = home?.score ?? '0';
+                const awayAbbr = away?.team?.abbreviation || '?';
+                const homeAbbr = home?.team?.abbreviation || '?';
+                scoreStr = `${awayAbbr} ${awayScore}, ${homeAbbr} ${homeScore}`;
+                statusStr = description || 'Final';
+            }
+            return `| ${gameLabel} | ${scoreStr} | ${statusStr} |`;
+        }).join('\n');
+        return `# ${emoji} ${leagueName} Scoreboard — ${today}\n\n| Game | Score | Status |\n|------|-------|--------|\n${rows}`;
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'ESPN scoreboard fetch failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}
+async function fetchEspnStandings(sport, league) {
+    try {
+        const apiUrl = `https://site.web.api.espn.com/apis/v2/sports/${sport}/${league}/standings?sort=winpercent:desc`;
+        const data = await fetchJson(apiUrl);
+        const children = data?.children || [];
+        const emoji = espnSportEmoji(sport, league);
+        const leagueName = data?.name || league.toUpperCase();
+        const today = fmtTodayESPN();
+        if (children.length === 0)
+            return null;
+        let output = `# ${emoji} ${leagueName} Standings — ${today}\n\n`;
+        for (const conf of children) {
+            const confName = conf.name || conf.abbreviation || 'Conference';
+            const entries = conf.standings?.entries || [];
+            output += `## ${confName}\n\n`;
+            output += `| # | Team | W | L | PCT | Streak |\n`;
+            output += `|---|------|---|---|-----|--------|\n`;
+            // Sort by playoff seed
+            const sorted = entries.slice().sort((a, b) => {
+                const seedA = a.stats?.find((s) => s.name === 'playoffSeed')?.value ?? 99;
+                const seedB = b.stats?.find((s) => s.name === 'playoffSeed')?.value ?? 99;
+                return seedA - seedB;
+            });
+            for (const entry of sorted) {
+                const team = entry.team?.displayName || '?';
+                const stats = entry.stats || [];
+                const getDisplay = (name) => stats.find((s) => s.name === name)?.displayValue || '?';
+                const getStat = (name) => stats.find((s) => s.name === name)?.value ?? '?';
+                const seed = getStat('playoffSeed');
+                const wins = getDisplay('wins');
+                const losses = getDisplay('losses');
+                const pct = getDisplay('winPercent');
+                const streak = getDisplay('streak');
+                output += `| ${seed} | ${team} | ${wins} | ${losses} | ${pct} | ${streak} |\n`;
+            }
+            output += '\n';
+        }
+        return output.trim();
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'ESPN standings fetch failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}
+export async function espnExtractor(_html, url) {
+    const match = matchESPN(url);
+    if (!match)
+        return null;
+    const { sport, league, type } = match;
+    const domain = 'espn.com';
+    if (type === 'standings') {
+        const content = await fetchEspnStandings(sport, league);
+        if (!content)
+            return null;
+        return {
+            domain,
+            type: 'standings',
+            structured: { sport, league, dataType: 'standings' },
+            cleanContent: content,
+        };
+    }
+    if (type === 'team') {
+        // Try to get team info from the teams API
+        try {
+            const teamsUrl = `https://site.api.espn.com/apis/site/v2/sports/${sport}/${league}/teams`;
+            const teamsData = await fetchJson(teamsUrl);
+            const teams = teamsData?.sports?.[0]?.leagues?.[0]?.teams || [];
+            const param = match.param?.toLowerCase();
+            const teamEntry = param
+                ? teams.find((t) => {
+                    const td = t.team || t;
+                    return td.abbreviation?.toLowerCase() === param ||
+                        td.slug?.toLowerCase() === param ||
+                        td.displayName?.toLowerCase().includes(param);
+                })
+                : teams[0];
+            if (teamEntry) {
+                const td = teamEntry.team || teamEntry;
+                const emoji = espnSportEmoji(sport, league);
+                const content = `# ${emoji} ${td.displayName}\n\n**League:** ${league.toUpperCase()}\n\n*For live scores and standings, use:*\n- \`webpeel "https://espn.com/${league}/scoreboard"\`\n- \`webpeel "https://espn.com/${league}/standings"\``;
+                return {
+                    domain,
+                    type: 'team',
+                    structured: { sport, league, teamName: td.displayName, abbreviation: td.abbreviation },
+                    cleanContent: content,
+                };
+            }
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'ESPN team fetch failed:', e instanceof Error ? e.message : e);
+        }
+        // Fallback to scoreboard
+    }
+    // Default: scoreboard
+    const content = await fetchEspnScoreboard(sport, league);
+    if (!content)
+        return null;
+    return {
+        domain,
+        type: 'scoreboard',
+        structured: { sport, league, dataType: 'scoreboard' },
+        cleanContent: content,
+    };
+}

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

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

package/dist/ee/extractors/etsy.js

@@ -0,0 +1,52 @@
+// ---------------------------------------------------------------------------
+// Etsy extractor (bot-block fallback with Google site-search suggestion)
+// ---------------------------------------------------------------------------
+export async function etsyExtractor(_html, url) {
+    const u = new URL(url);
+    // Extract search query from various URL patterns
+    // /search?q=handmade+jewelry  OR  /search/handmade-jewelry
+    let query = u.searchParams.get('q') || '';
+    if (!query) {
+        const pathMatch = u.pathname.match(/\/search\/([^?#]+)/);
+        if (pathMatch)
+            query = decodeURIComponent(pathMatch[1].replace(/-/g, ' '));
+    }
+    // Shop page: /shop/ShopName
+    const shopMatch = u.pathname.match(/^\/shop\/([^/?#]+)/);
+    const shopName = shopMatch?.[1] || '';
+    if (!query && !shopName)
+        return null;
+    const googleUrl = query
+        ? `https://www.google.com/search?q=site:etsy.com+${encodeURIComponent(query)}`
+        : `https://www.google.com/search?q=site:etsy.com+${encodeURIComponent(shopName)}`;
+    const etsySearchUrl = query ? `https://www.etsy.com/search?q=${encodeURIComponent(query)}` : url;
+    const displayTitle = query ? `"${query}"` : `Shop: ${shopName}`;
+    const cleanContent = [
+        `# 🎨 Etsy — ${displayTitle}`,
+        '',
+        '> ⚠️ Etsy blocks automated access. WebPeel cannot scrape listings directly.',
+        '',
+        '**Alternatives that work:**',
+        `- \`webpeel "${googleUrl}"\` — Google site:etsy.com results`,
+        `- Direct link: [etsy.com/search?q=${encodeURIComponent(query || shopName)}](${etsySearchUrl})`,
+        '',
+        ...(query ? [
+            '**Similar items on open marketplaces:**',
+            `- \`webpeel "https://www.ebay.com/sch/i.html?_nkw=${encodeURIComponent(query)}&LH_BIN=1"\` — eBay`,
+            `- \`webpeel "https://newyork.craigslist.org/search/sss?query=${encodeURIComponent(query)}"\` — Craigslist`,
+        ] : []),
+        '',
+        '*Etsy Open API v3 (free key at etsy.com/developers) can unlock direct access.*',
+    ].join('\n');
+    return {
+        domain: 'etsy.com',
+        type: 'blocked',
+        structured: {
+            query,
+            shopName,
+            reason: 'bot-block',
+            googleFallback: googleUrl,
+        },
+        cleanContent,
+    };
+}

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

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

package/dist/ee/extractors/facebook.js

@@ -0,0 +1,46 @@
+// ---------------------------------------------------------------------------
+// Facebook Marketplace extractor (login-wall fallback)
+// ---------------------------------------------------------------------------
+export async function facebookMarketplaceExtractor(_html, url) {
+    const u = new URL(url);
+    if (!u.pathname.includes('/marketplace'))
+        return null;
+    const query = u.searchParams.get('query') || '';
+    const maxPrice = u.searchParams.get('maxPrice') || '';
+    const minPrice = u.searchParams.get('minPrice') || '';
+    // Extract location segment: /marketplace/nyc/search → "nyc"
+    const locationMatch = u.pathname.match(/\/marketplace\/([^/]+)(?:\/|$)/);
+    const location = (locationMatch?.[1] && locationMatch[1] !== 'search' && locationMatch[1] !== 'category') ? locationMatch[1] : '';
+    const priceRange = [minPrice && `$${minPrice}`, maxPrice && `$${maxPrice}`].filter(Boolean).join(' – ');
+    const lines = [
+        `# 🛒 Facebook Marketplace`,
+        '',
+        `**Search:** ${query || 'Browse all'}`,
+        ...(location ? [`**Location:** ${location}`] : []),
+        ...(priceRange ? [`**Price range:** ${priceRange}`] : []),
+        '',
+        '> ⚠️ Facebook Marketplace requires authentication. WebPeel cannot access listings directly.',
+        '',
+        '**Alternative searches that work:**',
+    ];
+    if (query) {
+        const clUrl = `https://newyork.craigslist.org/search/sss?query=${encodeURIComponent(query)}${maxPrice ? '&max_price=' + maxPrice : ''}`;
+        const carsUrl = `https://www.cars.com/shopping/results/?keyword=${encodeURIComponent(query)}&list_price_max=${maxPrice || ''}&zip=10001&stock_type=used`;
+        const ebayUrl = `https://www.ebay.com/sch/i.html?_nkw=${encodeURIComponent(query)}${maxPrice ? '&_udhi=' + maxPrice : ''}&LH_BIN=1`;
+        lines.push(`- \`webpeel "${clUrl}"\` — Craigslist`, `- \`webpeel "${carsUrl}"\` — Cars.com`, `- \`webpeel "${ebayUrl}"\` — eBay`);
+    }
+    lines.push('', '*Tip: Craigslist and Cars.com return full structured results with WebPeel.*');
+    return {
+        domain: 'facebook.com',
+        type: 'blocked',
+        structured: {
+            query,
+            location,
+            minPrice,
+            maxPrice,
+            reason: 'authentication required',
+            alternatives: ['craigslist', 'cars.com', 'ebay'],
+        },
+        cleanContent: lines.join('\n'),
+    };
+}

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

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

package/dist/ee/extractors/github.js

@@ -0,0 +1,196 @@
+import { fetchJson, fetchJsonWithRetry } from './shared.js';
+// ---------------------------------------------------------------------------
+// 3. GitHub extractor
+// ---------------------------------------------------------------------------
+export async function githubExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const pathParts = urlObj.pathname.split('/').filter(Boolean);
+    const domain = 'github.com';
+    if (pathParts.length === 0)
+        return null;
+    const ghHeaders = { Accept: 'application/vnd.github.v3+json' };
+    // Use GITHUB_TOKEN if available for higher rate limits (5000/hr vs 60/hr)
+    const ghToken = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+    if (ghToken)
+        ghHeaders.Authorization = `token ${ghToken}`;
+    // User profile: /username (single segment)
+    if (pathParts.length === 1) {
+        const username = pathParts[0];
+        const userData = await fetchJson(`https://api.github.com/users/${username}`, ghHeaders);
+        if (!userData || userData.message === 'Not Found')
+            return null;
+        const structured = {
+            login: userData.login,
+            name: userData.name || userData.login,
+            bio: userData.bio || '',
+            company: userData.company || null,
+            location: userData.location || null,
+            blog: userData.blog || null,
+            followers: userData.followers ?? 0,
+            following: userData.following ?? 0,
+            publicRepos: userData.public_repos ?? 0,
+            created: userData.created_at,
+            avatarUrl: userData.avatar_url,
+        };
+        const cleanContent = `## 👤 GitHub: ${structured.name} (@${structured.login})
+
+${structured.bio ? structured.bio + '\n\n' : ''}📍 ${structured.location || 'N/A'}  |  💼 ${structured.company || 'N/A'}  |  🌐 ${structured.blog || 'N/A'}
+👥 ${structured.followers} followers  |  Following: ${structured.following}  |  📦 ${structured.publicRepos} public repos`;
+        return { domain, type: 'user', structured, cleanContent };
+    }
+    const owner = pathParts[0];
+    const repo = pathParts[1];
+    // Issue: /owner/repo/issues/123
+    if (pathParts[2] === 'issues' && pathParts[3]) {
+        const issueNumber = pathParts[3];
+        const [issueData, commentsData] = await Promise.all([
+            fetchJson(`https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}`, ghHeaders),
+            fetchJson(`https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}/comments?per_page=20`, ghHeaders),
+        ]);
+        if (!issueData || issueData.message === 'Not Found')
+            return null;
+        const comments = Array.isArray(commentsData)
+            ? commentsData.map((c) => ({
+                author: c.user?.login || 'ghost',
+                text: c.body || '',
+                created: c.created_at,
+            }))
+            : [];
+        const structured = {
+            repo: `${owner}/${repo}`,
+            number: issueData.number,
+            title: issueData.title || '',
+            author: issueData.user?.login || 'ghost',
+            state: issueData.state,
+            body: issueData.body || '',
+            labels: (issueData.labels || []).map((l) => l.name),
+            created: issueData.created_at,
+            updated: issueData.updated_at,
+            commentCount: issueData.comments ?? 0,
+            comments,
+        };
+        const labelStr = structured.labels.length ? structured.labels.join(', ') : 'none';
+        const commentsMd = comments.slice(0, 10).map((c) => `**@${c.author}** (${c.created}):\n${c.text.slice(0, 300)}`).join('\n\n---\n\n');
+        const cleanContent = `## 🐛 Issue #${structured.number}: ${structured.title}
+
+**Repo:** ${structured.repo}  |  **State:** ${structured.state}  |  **Author:** @${structured.author}
+**Labels:** ${labelStr}  |  **Created:** ${structured.created}
+
+${structured.body.slice(0, 800)}
+
+---
+
+### Comments (${structured.commentCount})
+
+${commentsMd || '*No comments.*'}`;
+        return { domain, type: 'issue', structured, cleanContent };
+    }
+    // Pull request: /owner/repo/pull/123
+    if (pathParts[2] === 'pull' && pathParts[3]) {
+        const prNumber = pathParts[3];
+        const [prData, commentsData] = await Promise.all([
+            fetchJson(`https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}`, ghHeaders),
+            fetchJson(`https://api.github.com/repos/${owner}/${repo}/issues/${prNumber}/comments?per_page=20`, ghHeaders),
+        ]);
+        if (!prData || prData.message === 'Not Found')
+            return null;
+        const comments = Array.isArray(commentsData)
+            ? commentsData.map((c) => ({
+                author: c.user?.login || 'ghost',
+                text: c.body || '',
+                created: c.created_at,
+            }))
+            : [];
+        const structured = {
+            repo: `${owner}/${repo}`,
+            number: prData.number,
+            title: prData.title || '',
+            author: prData.user?.login || 'ghost',
+            state: prData.state,
+            merged: prData.merged ?? false,
+            body: prData.body || '',
+            labels: (prData.labels || []).map((l) => l.name),
+            created: prData.created_at,
+            updated: prData.updated_at,
+            commentCount: prData.comments ?? 0,
+            additions: prData.additions ?? 0,
+            deletions: prData.deletions ?? 0,
+            changedFiles: prData.changed_files ?? 0,
+            headBranch: prData.head?.label || '',
+            baseBranch: prData.base?.label || '',
+            comments,
+        };
+        const labelStr = structured.labels.length ? structured.labels.join(', ') : 'none';
+        const commentsMd = comments.slice(0, 8).map((c) => `**@${c.author}** (${c.created}):\n${c.text.slice(0, 300)}`).join('\n\n---\n\n');
+        const cleanContent = `## 🔀 PR #${structured.number}: ${structured.title}
+
+**Repo:** ${structured.repo}  |  **State:** ${structured.state}${structured.merged ? ' (merged)' : ''}  |  **Author:** @${structured.author}
+**Labels:** ${labelStr}  |  **${structured.headBranch} → ${structured.baseBranch}**
+**Changes:** +${structured.additions} / -${structured.deletions} across ${structured.changedFiles} files
+
+${structured.body.slice(0, 800)}
+
+---
+
+### Comments (${structured.commentCount})
+
+${commentsMd || '*No comments.*'}`;
+        return { domain, type: 'pull_request', structured, cleanContent };
+    }
+    // Repository page: /owner/repo (and no deeper path we handle above)
+    if (pathParts.length >= 2) {
+        // Sequential fetches to avoid secondary rate limits on popular repos
+        const repoData = await fetchJsonWithRetry(`https://api.github.com/repos/${owner}/${repo}`, ghHeaders, 2, 1000);
+        if (!repoData) {
+            console.warn(`[webpeel:github] repo API returned null for ${owner}/${repo}`);
+            return null;
+        }
+        if (repoData.message) {
+            console.warn(`[webpeel:github] repo API error for ${owner}/${repo}: ${repoData.message}`);
+            if (repoData.message === 'Not Found')
+                return null;
+            if (repoData.message.includes('secondary rate limit') || repoData.message.includes('abuse'))
+                return null;
+        }
+        const structured = {
+            title: `${owner}/${repo}`,
+            name: `${owner}/${repo}`,
+            description: repoData.description || '',
+            stars: repoData.stargazers_count ?? 0,
+            forks: repoData.forks_count ?? 0,
+            watchers: repoData.watchers_count ?? 0,
+            language: repoData.language || null,
+            topics: repoData.topics || [],
+            license: repoData.license?.spdx_id || null,
+            openIssues: repoData.open_issues_count ?? 0,
+            lastPush: repoData.pushed_at,
+            createdAt: repoData.created_at,
+            defaultBranch: repoData.default_branch || 'main',
+            homepage: repoData.homepage || null,
+            archived: repoData.archived || false,
+            fork: repoData.fork || false,
+            url: repoData.html_url || `https://github.com/${owner}/${repo}`,
+        };
+        const topicsStr = structured.topics.length ? structured.topics.slice(0, 8).join(', ') : '';
+        const updatedDate = structured.lastPush ? structured.lastPush.slice(0, 10) : 'N/A';
+        const lines = [
+            `# 💻 ${structured.name}`,
+            '',
+            structured.description ? `**${structured.description}**` : '*No description.*',
+            '',
+            `- ⭐ Stars: ${structured.stars.toLocaleString()} | 🍴 Forks: ${structured.forks.toLocaleString()} | 📝 Language: ${structured.language || 'N/A'}`,
+            `- 📦 License: ${structured.license || 'None'} | 🔄 Updated: ${updatedDate}`,
+            `- 📊 Open Issues: ${structured.openIssues}${structured.archived ? ' | ⚠️ ARCHIVED' : ''}`,
+        ];
+        if (topicsStr)
+            lines.push(`- 🏷️ Topics: ${topicsStr}`);
+        lines.push('');
+        const links = [`[Repository](${structured.url})`];
+        if (structured.homepage)
+            links.push(`[Homepage](${structured.homepage})`);
+        lines.push(`**Links:** ${links.join(' · ')}`);
+        const cleanContent = lines.join('\n');
+        return { domain, type: 'repository', structured, cleanContent };
+    }
+    return null;
+}

package/dist/ee/extractors/google-flights.d.ts

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