@iflow-mcp/jakeliume-webpeel 0.22.0

package/dist/ee/domain-extractors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Domain-aware structured extractors for WebPeel.
+ *
+ * This file re-exports from individual extractor files for backward compatibility.
+ * Each extractor now lives in its own file under src/ee/extractors/.
+ */
+export { getDomainExtractor, hasDomainExtractor, extractDomainData, clearExtractorCache, setExtractorRedis, } from './extractors/index.js';
+export type { DomainExtractResult, DomainExtractor } from './extractors/index.js';

package/dist/ee/domain-extractors.js

@@ -0,0 +1,8 @@
+/**
+ * Domain-aware structured extractors for WebPeel.
+ *
+ * This file re-exports from individual extractor files for backward compatibility.
+ * Each extractor now lives in its own file under src/ee/extractors/.
+ */
+// Re-exported from individual extractor files for backward compatibility
+export { getDomainExtractor, hasDomainExtractor, extractDomainData, clearExtractorCache, setExtractorRedis, } from './extractors/index.js';

package/dist/ee/domain-intel.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Domain Intelligence — premium server-only optimisation.
+ *
+ * Learns from historical fetch outcomes which domains require browser or
+ * stealth mode, so subsequent requests skip the slow simple→browser
+ * escalation path and go straight to the right strategy.
+ *
+ * Uses an exponential moving average for latency tracking and requires a
+ * minimum sample count before issuing recommendations to avoid false
+ * positives from one-off failures.
+ *
+ * This module is NOT shipped in the npm package.
+ */
+import type { StrategyHooks } from '../core/strategy-hooks.js';
+export declare function clearDomainIntel(): void;
+export declare function createDomainIntelHooks(): Pick<StrategyHooks, 'getDomainRecommendation' | 'recordDomainResult'>;

package/dist/ee/domain-intel.js

@@ -0,0 +1,133 @@
+/**
+ * Domain Intelligence — premium server-only optimisation.
+ *
+ * Learns from historical fetch outcomes which domains require browser or
+ * stealth mode, so subsequent requests skip the slow simple→browser
+ * escalation path and go straight to the right strategy.
+ *
+ * Uses an exponential moving average for latency tracking and requires a
+ * minimum sample count before issuing recommendations to avoid false
+ * positives from one-off failures.
+ *
+ * This module is NOT shipped in the npm package.
+ */
+/* ---------- configuration ----------------------------------------------- */
+const MAX_DOMAINS = 500;
+const TTL_MS = 60 * 60 * 1000; // 1 hour
+const EMA_ALPHA = 0.3;
+const MIN_SAMPLES = 3;
+/* ---------- state ------------------------------------------------------- */
+const domainIntel = new Map();
+const methodCounts = new Map();
+/* ---------- internals --------------------------------------------------- */
+function domainKey(url) {
+    try {
+        return new URL(url).hostname.toLowerCase();
+    }
+    catch {
+        return '';
+    }
+}
+function prune(now) {
+    for (const [key, intel] of domainIntel) {
+        if (now - intel.lastSeen > TTL_MS) {
+            domainIntel.delete(key);
+            methodCounts.delete(key);
+        }
+    }
+}
+/* ---------- hook implementations ---------------------------------------- */
+function getDomainRecommendation(url) {
+    const key = domainKey(url);
+    if (!key)
+        return null;
+    const intel = domainIntel.get(key);
+    if (!intel)
+        return null;
+    const now = Date.now();
+    if (now - intel.lastSeen > TTL_MS) {
+        domainIntel.delete(key);
+        methodCounts.delete(key);
+        return null;
+    }
+    if (intel.sampleCount < MIN_SAMPLES)
+        return null;
+    const counts = methodCounts.get(key);
+    if (!counts)
+        return null;
+    // LRU touch
+    domainIntel.delete(key);
+    domainIntel.set(key, intel);
+    // All samples needed stealth → recommend stealth
+    if (counts.stealth === intel.sampleCount && intel.needsStealth) {
+        return { mode: 'stealth' };
+    }
+    // All samples needed browser (never succeeded with simple) → recommend browser
+    if (counts.simple === 0 &&
+        counts.browser + counts.stealth === intel.sampleCount &&
+        intel.needsBrowser) {
+        return { mode: 'browser' };
+    }
+    return null;
+}
+function recordDomainResult(url, method, latencyMs) {
+    const key = domainKey(url);
+    if (!key)
+        return;
+    const now = Date.now();
+    prune(now);
+    const existing = domainIntel.get(key);
+    const sanitizedLatency = Number.isFinite(latencyMs) && latencyMs > 0
+        ? latencyMs
+        : (existing?.avgLatencyMs ?? 0);
+    const next = existing
+        ? {
+            needsBrowser: existing.needsBrowser ||
+                method === 'browser' ||
+                method === 'stealth',
+            needsStealth: existing.needsStealth || method === 'stealth',
+            avgLatencyMs: existing.avgLatencyMs === 0
+                ? sanitizedLatency
+                : existing.avgLatencyMs * (1 - EMA_ALPHA) +
+                    sanitizedLatency * EMA_ALPHA,
+            lastSeen: now,
+            sampleCount: existing.sampleCount + 1,
+        }
+        : {
+            needsBrowser: method === 'browser' || method === 'stealth',
+            needsStealth: method === 'stealth',
+            avgLatencyMs: sanitizedLatency,
+            lastSeen: now,
+            sampleCount: 1,
+        };
+    const existingCounts = methodCounts.get(key) ?? {
+        simple: 0,
+        browser: 0,
+        stealth: 0,
+    };
+    existingCounts[method] += 1;
+    // Delete-then-set for LRU ordering
+    domainIntel.delete(key);
+    domainIntel.set(key, next);
+    methodCounts.set(key, existingCounts);
+    // Evict oldest when over capacity
+    while (domainIntel.size > MAX_DOMAINS) {
+        const oldest = domainIntel.keys().next().value;
+        if (!oldest)
+            break;
+        domainIntel.delete(oldest);
+        methodCounts.delete(oldest);
+    }
+}
+/* ---------- cleanup ----------------------------------------------------- */
+export function clearDomainIntel() {
+    domainIntel.clear();
+    methodCounts.clear();
+}
+/* ---------- public export ----------------------------------------------- */
+export function createDomainIntelHooks() {
+    return {
+        getDomainRecommendation,
+        recordDomainResult,
+    };
+}

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

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

package/dist/ee/extractors/allrecipes.js

@@ -0,0 +1,120 @@
+import { tryParseJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// 15. Allrecipes (Recipe Sites) extractor
+// ---------------------------------------------------------------------------
+export async function allrecipesExtractor(html, url) {
+    try {
+        const { load } = await import('cheerio');
+        const $ = load(html);
+        // Try Schema.org Recipe JSON-LD first
+        let recipe = null;
+        $('script[type="application/ld+json"]').each((_, el) => {
+            if (recipe)
+                return;
+            const raw = $(el).html() || '';
+            const parsed = tryParseJson(raw);
+            // Can be an array or direct object
+            const candidates = Array.isArray(parsed) ? parsed : [parsed];
+            for (const item of candidates) {
+                if (item?.['@type'] === 'Recipe' || (Array.isArray(item?.['@type']) && item['@type'].includes('Recipe'))) {
+                    recipe = item;
+                    break;
+                }
+                // Sometimes it's nested in @graph
+                if (item?.['@graph']) {
+                    const graphRecipe = item['@graph'].find((g) => g?.['@type'] === 'Recipe');
+                    if (graphRecipe) {
+                        recipe = graphRecipe;
+                        break;
+                    }
+                }
+            }
+        });
+        let title;
+        let ingredients = [];
+        let instructions = [];
+        let prepTime = '';
+        let cookTime = '';
+        let totalTime = '';
+        let servings = '';
+        let rating = '';
+        let reviewCount = '';
+        let description = '';
+        if (recipe) {
+            title = recipe.name || '';
+            description = recipe.description || '';
+            ingredients = (recipe.recipeIngredient || []).map((i) => i.trim());
+            // Instructions can be strings or HowToStep objects
+            const rawInstructions = recipe.recipeInstructions || [];
+            for (const step of rawInstructions) {
+                if (typeof step === 'string')
+                    instructions.push(step.trim());
+                else if (step.text)
+                    instructions.push(step.text.trim());
+                else if (step['@type'] === 'HowToSection' && step.itemListElement) {
+                    for (const s of step.itemListElement) {
+                        if (s.text)
+                            instructions.push(s.text.trim());
+                    }
+                }
+            }
+            // Parse ISO 8601 duration (PT30M, PT1H30M)
+            const parseDuration = (d) => {
+                if (!d)
+                    return '';
+                const h = d.match(/(\d+)H/)?.[1];
+                const m = d.match(/(\d+)M/)?.[1];
+                return [h ? `${h}h` : '', m ? `${m}m` : ''].filter(Boolean).join(' ');
+            };
+            prepTime = parseDuration(recipe.prepTime || '');
+            cookTime = parseDuration(recipe.cookTime || '');
+            totalTime = parseDuration(recipe.totalTime || '');
+            servings = String(recipe.recipeYield || '');
+            rating = recipe.aggregateRating?.ratingValue ? String(recipe.aggregateRating.ratingValue) : '';
+            reviewCount = recipe.aggregateRating?.reviewCount ? String(recipe.aggregateRating.reviewCount) : '';
+        }
+        else {
+            // HTML fallback
+            title = $('h1').first().text().trim() ||
+                $('meta[property="og:title"]').attr('content') || '';
+            description = $('meta[property="og:description"]').attr('content') || '';
+            $('[class*="ingredient"]').each((_, el) => {
+                const text = $(el).text().trim();
+                if (text && text.length < 200)
+                    ingredients.push(text);
+            });
+            $('[class*="instruction"] li, [class*="step"] li').each((_, el) => {
+                const text = $(el).text().trim();
+                if (text)
+                    instructions.push(text);
+            });
+        }
+        if (!title)
+            return null;
+        const structured = {
+            title, description, ingredients, instructions,
+            prepTime, cookTime, totalTime, servings, rating, reviewCount, url,
+        };
+        const timeParts = [
+            prepTime ? `Prep: ${prepTime}` : '',
+            cookTime ? `Cook: ${cookTime}` : '',
+            totalTime ? `Total: ${totalTime}` : '',
+        ].filter(Boolean).join(' | ');
+        const metaLine = [
+            timeParts,
+            servings ? `Servings: ${servings}` : '',
+            rating ? `Rating: ${rating}${reviewCount ? ` (${reviewCount} reviews)` : ''}` : '',
+        ].filter(Boolean).join(' | ');
+        const ingredientsMd = ingredients.length
+            ? `## Ingredients\n\n${ingredients.map(i => `- ${i}`).join('\n')}`
+            : '';
+        const instructionsMd = instructions.length
+            ? `## Instructions\n\n${instructions.map((s, i) => `${i + 1}. ${s}`).join('\n')}`
+            : '';
+        const cleanContent = `# 🍽️ ${title}\n\n${metaLine ? `*${metaLine}*\n\n` : ''}${description ? description + '\n\n' : ''}${ingredientsMd}\n\n${instructionsMd}`.trim();
+        return { domain: 'allrecipes.com', type: 'recipe', structured, cleanContent };
+    }
+    catch {
+        return null;
+    }
+}

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

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

package/dist/ee/extractors/amazon.js

@@ -0,0 +1,78 @@
+import { tryParseJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// 12. Amazon Products extractor
+// ---------------------------------------------------------------------------
+export async function amazonExtractor(html, url) {
+    try {
+        const { load } = await import('cheerio');
+        const $ = load(html);
+        // Extract from JSON-LD first
+        let jsonLdData = null;
+        $('script[type="application/ld+json"]').each((_, el) => {
+            if (jsonLdData)
+                return;
+            const raw = $(el).html() || '';
+            const parsed = tryParseJson(raw);
+            if (parsed?.['@type'] === 'Product')
+                jsonLdData = parsed;
+        });
+        // Meta tag fallbacks
+        const ogTitle = $('meta[property="og:title"]').attr('content') || '';
+        const ogDescription = $('meta[property="og:description"]').attr('content') || '';
+        const ogImage = $('meta[property="og:image"]').attr('content') || '';
+        // HTML selectors
+        const title = jsonLdData?.name ||
+            $('#productTitle').text().trim() ||
+            $('#title').text().trim() ||
+            ogTitle;
+        if (!title)
+            return null;
+        const priceWhole = $('#priceblock_ourprice').text().trim() ||
+            $('.a-price .a-offscreen').first().text().trim() ||
+            $('[data-asin-price]').first().attr('data-asin-price') || '';
+        const rating = jsonLdData?.aggregateRating?.ratingValue ||
+            $('#acrPopover .a-size-base.a-color-base').first().text().trim() ||
+            $('span[data-hook="rating-out-of-text"]').text().trim() || '';
+        const reviewCount = jsonLdData?.aggregateRating?.reviewCount ||
+            $('#acrCustomerReviewText').text().replace(/[^0-9,]/g, '').trim() || '';
+        const availability = jsonLdData?.offers?.availability?.replace('https://schema.org/', '') ||
+            $('#availability span').first().text().trim() || '';
+        const description = jsonLdData?.description ||
+            $('#feature-bullets .a-list-item').map((_, el) => $(el).text().trim()).get().join('\n') ||
+            $('#productDescription p').text().trim() ||
+            ogDescription;
+        const features = [];
+        $('#feature-bullets li').each((_, el) => {
+            const text = $(el).text().trim();
+            if (text && !text.includes('Make sure this fits'))
+                features.push(text);
+        });
+        // ASIN from URL
+        const asinMatch = url.match(/\/dp\/([A-Z0-9]{10})/i);
+        const asin = asinMatch?.[1] || '';
+        const structured = {
+            title,
+            price: priceWhole,
+            rating,
+            reviewCount,
+            availability,
+            description,
+            features,
+            asin,
+            image: ogImage,
+            url,
+        };
+        const ratingLine = rating ? `\n**Rating:** ${rating}${reviewCount ? ` (${reviewCount} reviews)` : ''}` : '';
+        const priceLine = priceWhole ? `\n**Price:** ${priceWhole}` : '';
+        const availLine = availability ? `\n**Availability:** ${availability}` : '';
+        const featuresSection = features.length
+            ? `\n\n## Features\n\n${features.map(f => `- ${f}`).join('\n')}`
+            : '';
+        const descSection = description ? `\n\n## Description\n\n${description.substring(0, 1000)}` : '';
+        const cleanContent = `# 🛒 ${title}${priceLine}${ratingLine}${availLine}${descSection}${featuresSection}`;
+        return { domain: 'amazon.com', type: 'product', structured, cleanContent };
+    }
+    catch {
+        return null;
+    }
+}

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

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

package/dist/ee/extractors/arxiv.js

@@ -0,0 +1,137 @@
+import { simpleFetch } from '../../core/fetcher.js';
+import { stripHtml } from './shared.js';
+// ---------------------------------------------------------------------------
+// 7. ArXiv extractor (ArXiv API)
+// ---------------------------------------------------------------------------
+export async function arxivExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const path = urlObj.pathname;
+    // --- Search page: /search/?query=... or /search/?searchtype=all&query=... ---
+    if (path.startsWith('/search')) {
+        const rawQuery = urlObj.searchParams.get('query') || '';
+        if (!rawQuery)
+            return null;
+        try {
+            const searchQuery = encodeURIComponent(`all:${rawQuery}`);
+            const apiUrl = `https://export.arxiv.org/api/query?search_query=${searchQuery}&max_results=10&sortBy=relevance`;
+            const result = await simpleFetch(apiUrl, 'WebPeel/0.21', 20000, { Accept: 'application/xml' });
+            if (!result?.html)
+                return null;
+            const xml = result.html;
+            // Parse total results count from opensearch:totalResults
+            const totalMatch = xml.match(/<opensearch:totalResults[^>]*>(\d+)<\/opensearch:totalResults>/);
+            const total = totalMatch ? parseInt(totalMatch[1], 10) : 0;
+            // Parse all entries
+            const entries = [...xml.matchAll(/<entry[\s\S]*?<\/entry>/g)].map(m => m[0]);
+            const papers = entries.map(entryXml => {
+                const getTag = (tag) => {
+                    const match = entryXml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
+                    return match ? stripHtml(match[1]).trim() : '';
+                };
+                const getAllTags = (tag) => {
+                    const matches = [...entryXml.matchAll(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, 'g'))];
+                    return matches.map(m => stripHtml(m[1]).trim()).filter(Boolean);
+                };
+                const title = getTag('title');
+                const published = getTag('published');
+                const authors = getAllTags('name');
+                const summary = getTag('summary');
+                // Extract arXiv ID from <id> tag
+                const idTag = getTag('id');
+                const idMatch2 = idTag.match(/abs\/(\d{4}\.\d{4,5}(?:v\d+)?)/);
+                const paperId2 = idMatch2 ? idMatch2[1] : '';
+                // Categories
+                const cats = [...entryXml.matchAll(/category[^>]*term="([^"]+)"/g)].map(m => m[1]);
+                return { title, published: published?.split('T')[0], authors, summary, paperId: paperId2, categories: cats };
+            }).filter(p => p.title);
+            if (papers.length === 0)
+                return null;
+            const rows = papers.map((p, i) => {
+                const authorLine = p.authors.length === 0 ? '—'
+                    : p.authors.length === 1 ? p.authors[0]
+                        : `${p.authors[0]} et al.`;
+                const pdfLink = p.paperId ? ` [[PDF](https://arxiv.org/pdf/${p.paperId})]` : '';
+                return `| ${i + 1} | [${p.title}](https://arxiv.org/abs/${p.paperId}) | ${p.published || '?'} | ${authorLine} |${pdfLink}`;
+            }).join('\n');
+            const cleanContent = `# 🔍 arXiv Search — "${rawQuery}"\n\n| # | Paper | Published | Authors |\n|---|-------|-----------|--------|\n${rows}\n\n*Source: arXiv API · Total results: ${total.toLocaleString()}*`;
+            return {
+                domain: 'arxiv.org',
+                type: 'search',
+                structured: { query: rawQuery, total, papers },
+                cleanContent,
+            };
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'ArXiv search failed:', e instanceof Error ? e.message : e);
+            return null;
+        }
+    }
+    // Extract paper ID from URL patterns:
+    // /abs/2501.12948, /pdf/2501.12948, /abs/2501.12948v2
+    const idMatch = path.match(/\/(abs|pdf|html)\/(\d{4}\.\d{4,5}(?:v\d+)?)/);
+    if (!idMatch)
+        return null;
+    const paperId = idMatch[2];
+    try {
+        // Use ArXiv API
+        const apiUrl = `https://export.arxiv.org/api/query?id_list=${paperId}`;
+        const result = await simpleFetch(apiUrl, 'WebPeel/0.17.1', 15000, { Accept: 'application/xml' });
+        if (!result?.html)
+            return null;
+        const xml = result.html;
+        // Parse XML (simple regex-based for these known fields)
+        const getTag = (tag) => {
+            const match = xml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
+            return match ? stripHtml(match[1]).trim() : '';
+        };
+        // getAllTags removed — unused
+        // ArXiv Atom feed: <feed><title>query URL</title> ... <entry><title>Paper Title</title>...
+        // We must grab the entry title, not the feed title.
+        const entryMatch = xml.match(/<entry[\s\S]*?<\/entry>/);
+        const entryXml = entryMatch ? entryMatch[0] : xml;
+        const getEntryTag = (tag) => {
+            const match = entryXml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
+            return match ? stripHtml(match[1]).trim() : '';
+        };
+        const getAllEntryTags = (tag) => {
+            const matches = [...entryXml.matchAll(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, 'g'))];
+            return matches.map(m => stripHtml(m[1]).trim()).filter(Boolean);
+        };
+        const title = getEntryTag('title') || getTag('title');
+        const summary = getEntryTag('summary') || getTag('summary');
+        const published = getEntryTag('published') || getTag('published');
+        const updated = getEntryTag('updated') || getTag('updated');
+        const authors = getAllEntryTags('name');
+        // Extract categories
+        const categories = [...xml.matchAll(/category[^>]*term="([^"]+)"/g)].map(m => m[1]);
+        // Extract DOI and journal ref if available
+        const doi = getTag('arxiv:doi');
+        const journalRef = getTag('arxiv:journal_ref');
+        if (!title)
+            return null;
+        const structured = {
+            title,
+            authors,
+            abstract: summary,
+            published: published || undefined,
+            updated: updated || undefined,
+            categories,
+            doi: doi || undefined,
+            journalRef: journalRef || undefined,
+            paperId,
+            pdfUrl: `https://arxiv.org/pdf/${paperId}`,
+            absUrl: `https://arxiv.org/abs/${paperId}`,
+        };
+        const authorLine = authors.length <= 5
+            ? authors.join(', ')
+            : `${authors.slice(0, 5).join(', ')} et al. (${authors.length} authors)`;
+        const cleanContent = `# 📄 arXiv: ${title} (${paperId})\n\n**Authors:** ${authorLine}\n**Submitted:** ${published?.split('T')[0] || 'N/A'}${categories.length ? `\n**Categories:** ${categories.join(', ')}` : ''}${doi ? `\n**DOI:** ${doi}` : ''}${journalRef ? `\n**Journal:** ${journalRef}` : ''}\n\n## Abstract\n\n${summary}\n\n**PDF:** [Download](${structured.pdfUrl}) | **HTML:** [View](https://arxiv.org/html/${paperId})`;
+        return { domain: 'arxiv.org', type: 'paper', structured, cleanContent };
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'ArXiv API failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}

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

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

package/dist/ee/extractors/bestbuy.js

@@ -0,0 +1,78 @@
+import { fetchJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// 10. Best Buy extractor (Best Buy Products API)
+// ---------------------------------------------------------------------------
+export async function bestBuyExtractor(_html, url) {
+    const apiKey = process.env.BESTBUY_API_KEY;
+    if (!apiKey)
+        return null; // No API key, skip
+    // Extract SKU from URL: /site/.../6587822.p → 6587822
+    const skuMatch = url.match(/\/(\d{7,})\.p/);
+    if (!skuMatch)
+        return null;
+    const sku = skuMatch[1];
+    const apiUrl = `https://api.bestbuy.com/v1/products/${sku}.json?apiKey=${apiKey}&show=sku,name,salePrice,regularPrice,onSale,shortDescription,longDescription,image,largeFrontImage,url,customerReviewAverage,customerReviewCount,categoryPath,manufacturer,modelNumber,upc,freeShipping,inStoreAvailability,onlineAvailability,condition,features.feature`;
+    try {
+        const data = await fetchJson(apiUrl);
+        if (!data || data.error)
+            return null;
+        // Build clean markdown
+        const lines = [];
+        lines.push(`# ${data.name}`);
+        lines.push('');
+        if (data.onSale) {
+            lines.push(`**Sale Price:** $${data.salePrice} (was $${data.regularPrice})`);
+        }
+        else {
+            lines.push(`**Price:** $${data.regularPrice}`);
+        }
+        lines.push(`**SKU:** ${data.sku}`);
+        if (data.manufacturer)
+            lines.push(`**Brand:** ${data.manufacturer}`);
+        if (data.modelNumber)
+            lines.push(`**Model:** ${data.modelNumber}`);
+        if (data.customerReviewAverage) {
+            lines.push(`**Rating:** ${data.customerReviewAverage}/5 (${data.customerReviewCount} reviews)`);
+        }
+        lines.push(`**Availability:** ${data.onlineAvailability ? 'In Stock Online' : 'Out of Stock Online'} | ${data.inStoreAvailability ? 'Available In Store' : 'Not Available In Store'}`);
+        if (data.freeShipping)
+            lines.push('**Free Shipping:** Yes');
+        lines.push('');
+        if (data.shortDescription)
+            lines.push(data.shortDescription);
+        lines.push('');
+        if (data.longDescription)
+            lines.push(data.longDescription);
+        if (data.features?.feature) {
+            lines.push('');
+            lines.push('## Features');
+            for (const f of data.features.feature) {
+                lines.push(`- ${f}`);
+            }
+        }
+        const structured = {
+            sku: data.sku,
+            name: data.name,
+            price: data.salePrice || data.regularPrice,
+            regularPrice: data.regularPrice,
+            onSale: data.onSale,
+            brand: data.manufacturer,
+            model: data.modelNumber,
+            upc: data.upc,
+            rating: data.customerReviewAverage,
+            reviewCount: data.customerReviewCount,
+            image: data.largeFrontImage || data.image,
+            url: data.url,
+            inStock: data.onlineAvailability,
+            freeShipping: data.freeShipping,
+            condition: data.condition,
+            category: data.categoryPath?.map((c) => c.name).join(' > '),
+        };
+        return { domain: 'bestbuy.com', type: 'product', structured, cleanContent: lines.join('\n') };
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'Best Buy API failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}

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

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