webpeel 0.21.89 → 0.22.0

package/dist/server/routes/smart-search/handlers/products.js

@@ -0,0 +1,213 @@
+import { peel } from '../../../../index.js';
+import { getBestSearchProvider } from '../../../../core/search-provider.js';
+import { addAffiliateTag, getStoreInfo, parsePrice, cleanProductTitle } from '../utils.js';
+import { callLLMQuick, sanitizeSearchQuery, PROMPT_INJECTION_DEFENSE } from '../llm.js';
+export async function handleProductSearch(intent) {
+    const t0 = Date.now();
+    // Build clean product keyword (strip noise words)
+    const keyword = intent.query
+        .replace(/\b(buy|shop|shopping|purchase|order|deal|discount|sale|price|cheap|cheapest|best price|under)\b/gi, '')
+        .replace(/\$\d[\d,]*/g, '')
+        .replace(/\s+/g, ' ')
+        .trim() || intent.query;
+    // Parallel site-specific searches
+    const { provider: searchProvider } = getBestSearchProvider();
+    const isBulk = /\b(bulk|wholesale|1000|500|case|pallet|box of|pack of|carton)\b/i.test(intent.query);
+    const isGrocery = intent.params.isGrocery === 'true' || /\b(grocery|milk|eggs|bread|butter|cheese|chicken|produce)\b/i.test(intent.query);
+    const isCollectible = /\b(pokemon|pokémon|magic\s*the\s*gathering|mtg|yu-?gi-?oh|trading\s*card|tcg|baseball\s*card|sports\s*card|collectible\s*card|figurine|funko|hot\s*wheels|lego\s*set|vintage\s*toy|action\s*figure|comic\s*book|vinyl\s*record|rare\s*coin|stamp\s*collection)\b/i.test(intent.query);
+    let rawResults;
+    let redditResults;
+    if (isCollectible) {
+        const [tcgSettled, ebaySettled, etsySettled, fbAmazonSettled, redditSettled] = await Promise.allSettled([
+            searchProvider.searchWeb(`${keyword} price site:tcgplayer.com`, { count: 2 }),
+            searchProvider.searchWeb(`${keyword} price site:ebay.com sold`, { count: 2 }),
+            searchProvider.searchWeb(`${keyword} price site:etsy.com OR site:mercari.com`, { count: 3 }),
+            searchProvider.searchWeb(`${keyword} price site:facebook.com/marketplace OR site:amazon.com`, { count: 3 }),
+            searchProvider.searchWeb(`${keyword} cheapest reddit where to buy`, { count: 3 }),
+        ]);
+        rawResults = [
+            ...(tcgSettled.status === 'fulfilled' ? tcgSettled.value : []),
+            ...(ebaySettled.status === 'fulfilled' ? ebaySettled.value : []),
+            ...(etsySettled.status === 'fulfilled' ? etsySettled.value : []),
+            ...(fbAmazonSettled.status === 'fulfilled' ? fbAmazonSettled.value : []),
+        ];
+        redditResults = redditSettled.status === 'fulfilled' ? redditSettled.value : [];
+    }
+    else if (isGrocery) {
+        // Search grocery-specific sites
+        const [instacartSettled, walmartGrocerySettled, freshSettled, redditGrocerySettled] = await Promise.allSettled([
+            searchProvider.searchWeb(`${keyword} price site:instacart.com`, { count: 2 }),
+            searchProvider.searchWeb(`${keyword} price site:walmart.com/grocery OR site:walmart.com`, { count: 2 }),
+            searchProvider.searchWeb(`${keyword} price site:freshdirect.com OR site:wholefoodsmarket.com`, { count: 3 }),
+            searchProvider.searchWeb(`${keyword} cheapest grocery store reddit`, { count: 3 }),
+        ]);
+        rawResults = [
+            ...(instacartSettled.status === 'fulfilled' ? instacartSettled.value : []),
+            ...(walmartGrocerySettled.status === 'fulfilled' ? walmartGrocerySettled.value : []),
+            ...(freshSettled.status === 'fulfilled' ? freshSettled.value : []),
+        ];
+        redditResults = redditGrocerySettled.status === 'fulfilled' ? redditGrocerySettled.value : [];
+    }
+    else {
+        const [amazonSettled, walmartSettled, bestbuySettled, targetSettled, redditSettled] = await Promise.allSettled([
+            searchProvider.searchWeb(`${keyword} site:amazon.com ${isBulk ? '' : 'price'}`, { count: 3 }),
+            searchProvider.searchWeb(`${keyword} site:walmart.com price`, { count: 2 }),
+            searchProvider.searchWeb(`${keyword} site:bestbuy.com OR site:target.com price`, { count: 2 }),
+            isBulk
+                ? searchProvider.searchWeb(`${keyword} wholesale bulk site:uline.com OR site:alibaba.com OR site:staples.com OR site:webstaurantstore.com`, { count: 3 })
+                : searchProvider.searchWeb(`${keyword} site:ebay.com OR site:etsy.com price`, { count: 3 }),
+            searchProvider.searchWeb(`${keyword} reddit review best worth it`, { count: 2 }),
+        ]);
+        rawResults = [
+            ...(amazonSettled.status === 'fulfilled' ? amazonSettled.value : []),
+            ...(walmartSettled.status === 'fulfilled' ? walmartSettled.value : []),
+            ...(bestbuySettled.status === 'fulfilled' ? bestbuySettled.value : []),
+            ...(targetSettled.status === 'fulfilled' ? targetSettled.value : []),
+        ];
+        redditResults = redditSettled.status === 'fulfilled' ? redditSettled.value : [];
+    }
+    // Parse structured product listings from search results
+    // DEEP SCRAPE: Visit top marketplace pages to extract real prices (collectibles only)
+    let uniqueListings = [];
+    if (isCollectible) {
+        const scrapableUrls = rawResults
+            .filter(r => r.url && (r.url.includes('tcgplayer.com') ||
+            r.url.includes('ebay.com') ||
+            r.url.includes('amazon.com') ||
+            r.url.includes('etsy.com') ||
+            r.url.includes('mercari.com')))
+            .slice(0, 4)
+            .map(r => r.url);
+        const deepResults = await Promise.allSettled(scrapableUrls.map(url => peel(url, { render: false, timeout: 5000 })
+            .then(result => ({ url, content: result.content, title: result.title, tokens: result.tokens }))
+            .catch(() => null)));
+        const deepListings = [];
+        for (const settled of deepResults) {
+            if (settled.status !== 'fulfilled' || !settled.value)
+                continue;
+            const { url, content: pageContent } = settled.value;
+            if (!pageContent)
+                continue;
+            const sourceName = url.includes('tcgplayer') ? 'TCGPlayer'
+                : url.includes('ebay') ? 'eBay'
+                    : url.includes('amazon') ? 'Amazon'
+                        : url.includes('etsy') ? 'Etsy'
+                            : url.includes('mercari') ? 'Mercari'
+                                : new URL(url).hostname;
+            const lines = pageContent.split('\n');
+            for (const line of lines) {
+                const pm = line.match(/\$(\d{1,6}(?:\.\d{2})?)/);
+                if (!pm)
+                    continue;
+                const price = parseFloat(pm[1]);
+                if (price < 0.5 || price > 50000)
+                    continue;
+                const titleText = line.replace(/\$[\d,.]+/g, '').replace(/[|·\-–—]/g, ' ').trim().slice(0, 100);
+                if (titleText.length < 5)
+                    continue;
+                const conditionMatch = line.match(/\b(Near Mint|NM|Lightly Played|LP|Moderately Played|MP|Heavily Played|HP|Damaged|DMG|New|Used|Like New|Good|Very Good|Excellent)\b/i);
+                deepListings.push({
+                    title: titleText,
+                    price: '$' + price.toFixed(2),
+                    priceValue: price,
+                    url,
+                    source: sourceName,
+                    condition: conditionMatch ? conditionMatch[1] : undefined,
+                });
+            }
+        }
+        deepListings.sort((a, b) => a.priceValue - b.priceValue);
+        const seen = new Set();
+        uniqueListings = deepListings.filter(l => {
+            const key = l.price + l.source;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        }).slice(0, 6);
+    }
+    let listings = rawResults
+        .filter(r => r.url && getStoreInfo(r.url) !== null)
+        .map(r => {
+        const storeInfo = getStoreInfo(r.url);
+        const textToSearch = `${r.title || ''} ${r.snippet || ''}`;
+        // Extract price from snippet/title
+        const price = parsePrice(textToSearch);
+        // Extract rating from snippet
+        const ratingMatch = (r.snippet || '').match(/(\d+(?:\.\d)?)\s*(?:out of 5|stars?|★)/i);
+        const rating = ratingMatch ? parseFloat(ratingMatch[1]) : undefined;
+        // Extract review count
+        const reviewMatch = (r.snippet || '').match(/([\d,]+)\s*(?:ratings?|reviews?)/i);
+        const reviewCount = reviewMatch ? reviewMatch[1].replace(/,/g, '') : undefined;
+        // Clean up title
+        const title = cleanProductTitle(r.title || '');
+        // Extract brand from title — common patterns: "Brand Name Product..." or known brands
+        const KNOWN_BRANDS = /\b(Sony|Bose|Apple|Samsung|LG|JBL|Sennheiser|Audio-Technica|Beats|Jabra|Anker|Soundcore|AKG|Shure|Skullcandy|Plantronics|HyperX|SteelSeries|Razer|Corsair|Logitech|Dell|HP|Lenovo|Asus|Acer|MSI|Microsoft|Google|Amazon|Kindle|Echo|Ring|Roku|Dyson|iRobot|Roomba|Ninja|KitchenAid|Instant Pot|Keurig|Breville|Philips|Panasonic|Canon|Nikon|GoPro|DJI|Fitbit|Garmin|Xiaomi|OnePlus|Nothing|Motorola|Nokia|TCL|Hisense|Vizio|Sonos|Marshall|Bang & Olufsen|B&O|Nike|Adidas|New Balance|Puma|Under Armour|North Face|Patagonia|Columbia|Levi's|Oakley|Ray-Ban|Gucci|Coach|Kate Spade|Michael Kors|Samsonite|Osprey|Yeti|Hydro Flask|Stanley|Weber|Traeger|DeWalt|Makita|Milwaukee|Bosch|Black\+Decker|Craftsman|Ryobi)\b/i;
+        const brandMatch = (r.title || '').match(KNOWN_BRANDS);
+        const brand = brandMatch ? brandMatch[1] : undefined;
+        // Image from SearXNG (imageUrl field if available)
+        const image = r.imageUrl ?? undefined;
+        return {
+            title,
+            brand,
+            price,
+            rating,
+            reviewCount,
+            url: addAffiliateTag(r.url),
+            snippet: r.snippet,
+            store: storeInfo.store,
+            image,
+        };
+    })
+        .slice(0, 10);
+    // Replace listings with deep-scraped results for collectibles (if any found)
+    if (isCollectible && uniqueListings.length > 0) {
+        listings = uniqueListings.map(l => ({
+            title: l.title,
+            brand: undefined,
+            price: l.price,
+            rating: undefined,
+            reviewCount: undefined,
+            url: l.url,
+            snippet: l.condition ? `Condition: ${l.condition}` : '',
+            store: l.source,
+            image: undefined,
+        }));
+    }
+    const amazonUrl = addAffiliateTag(`https://www.amazon.com/s?k=${encodeURIComponent(keyword)}`);
+    const content = listings.length > 0
+        ? `# 🛍️ Products — ${keyword}\n\n${listings.map((l, i) => `${i + 1}. **${l.title}** — ${l.price || 'see price'} [${l.store}](${l.url})\n   ${l.snippet || ''}`).join('\n\n')}`
+        : `# 🛍️ Products — ${keyword}\n\nNo structured listings found. Try a more specific query.`;
+    // AI synthesis: recommend best value option
+    let answer;
+    if (process.env.OLLAMA_URL) {
+        const productInfo = listings.length > 0
+            ? listings.slice(0, 5).map(l => `${l.brand ? l.brand + ' ' : ''}${l.title}: ${l.price || 'N/A'} at ${l.store}${l.rating ? `, ${l.rating}★` : ''}${l.reviewCount ? ` (${l.reviewCount} reviews)` : ''}`).join(', ')
+            : 'no specific listings found';
+        const redditSnippets = redditResults.slice(0, 2).map(r => `${r.title}: ${r.snippet || ''}`).join('\n');
+        const deepPriceInfo = uniqueListings.length > 0
+            ? '\n\nReal prices found:\n' + uniqueListings.slice(0, 5).map((l, i) => `${i + 1}. ${l.title} — ${l.price} on ${l.source}${l.condition ? ` (${l.condition})` : ''}`).join('\n')
+            : '';
+        const aiPrompt = isCollectible
+            ? `${PROMPT_INJECTION_DEFENSE}You are a collectibles price expert. The user wants: "${sanitizeSearchQuery(intent.query)}". Products found: ${productInfo}.${deepPriceInfo} Reddit says: ${redditSnippets || 'none'}. List the cheapest options with exact prices, condition (near mint/lightly played/etc), and which store. Be specific with dollar amounts. Max 200 words. Cite sources inline as [1], [2], [3].`
+            : `${PROMPT_INJECTION_DEFENSE}You are a shopping advisor. The user wants: "${sanitizeSearchQuery(intent.query)}". Products found: ${productInfo}. Reddit says: ${redditSnippets || 'no reviews'}. ${listings.length > 0 ? 'Recommend the best value option. Mention the brand name, specific model, price, and store. Be specific.' : 'Give general buying advice with specific brand and model recommendations based on Reddit.'} Max 200 words. Cite sources inline as [1], [2], [3].`;
+        const aiText = await callLLMQuick(aiPrompt, { maxTokens: 250, timeoutMs: 5000, temperature: 0.4 });
+        if (aiText && aiText.length > 20)
+            answer = aiText;
+    }
+    return {
+        type: 'products',
+        source: listings.length > 0 ? 'Shopping + Reddit' : 'Web',
+        sourceUrl: amazonUrl,
+        content,
+        title: `${keyword} — Shopping`,
+        structured: { listings },
+        tokens: content.split(' ').length,
+        fetchTimeMs: Date.now() - t0,
+        ...(answer !== undefined ? { answer } : {}),
+        sources: [
+            { type: 'shopping', count: listings.length },
+            { type: 'reddit', threads: redditResults.slice(0, 3).map(r => ({ title: r.title, url: r.url, snippet: r.snippet })) },
+        ],
+    };
+}

package/dist/server/routes/smart-search/handlers/rental.d.ts

@@ -0,0 +1,2 @@
+import type { SearchIntent, SmartSearchResult } from '../types.js';
+export declare function handleRentalSearch(intent: SearchIntent): Promise<SmartSearchResult>;

package/dist/server/routes/smart-search/handlers/rental.js

@@ -0,0 +1,151 @@
+import { getBestSearchProvider } from '../../../../core/search-provider.js';
+import { addAffiliateTag, parsePrice, extractPriceValue } from '../utils.js';
+import { callLLMQuick, PROMPT_INJECTION_DEFENSE } from '../llm.js';
+export async function handleRentalSearch(intent) {
+    const t0 = Date.now();
+    // Extract location from query
+    const locMatch = intent.query.match(/\b(?:in|at|near|from|around)\s+(.+?)(?:\s+(?:for|under|from|to|between|\$|cheap|best).*)?$/i);
+    const location = locMatch ? locMatch[1].trim() : '';
+    // Extract dates if present
+    const dateMatch = intent.query.match(/(?:from|between)\s+(\w+\s+\d+)\s+(?:to|and|through|-)\s+(\w+\s+\d+)/i);
+    const dates = dateMatch ? { from: dateMatch[1], to: dateMatch[2] } : null;
+    // Extract budget if present
+    const budgetMatch = intent.query.match(/(?:under|\$|budget|max|cheaper than)\s*\$?(\d+)/i);
+    const budget = budgetMatch ? budgetMatch[1] : null;
+    const { provider: searchProvider } = getBestSearchProvider();
+    // Search for aggregator results that include prices + Reddit tips
+    const [aggregatorSettled, turoSettled, redditSettled] = await Promise.allSettled([
+        searchProvider.searchWeb(`car rental ${location || 'near me'} ${dates ? `${dates.from} to ${dates.to}` : ''} price cheapest site:kayak.com OR site:priceline.com OR site:expedia.com`, { count: 8 }),
+        searchProvider.searchWeb(`car rental ${location || ''} site:turo.com OR site:enterprise.com OR site:hertz.com`, { count: 3 }),
+        searchProvider.searchWeb(`car rental ${location || ''} reddit tips best deal cheapest`, { count: 2 }),
+    ]);
+    const rentalResults = [
+        ...(aggregatorSettled.status === 'fulfilled' ? aggregatorSettled.value : []),
+        ...(turoSettled.status === 'fulfilled' ? turoSettled.value : []),
+    ];
+    const redditResults = redditSettled.status === 'fulfilled' ? redditSettled.value : [];
+    // Known aggregators and direct providers
+    const RENTAL_SITES = {
+        'kayak.com': { name: 'Kayak', type: 'aggregator' },
+        'priceline.com': { name: 'Priceline', type: 'aggregator' },
+        'cheapflights.com': { name: 'Cheapflights', type: 'aggregator' },
+        'momondo.com': { name: 'Momondo', type: 'aggregator' },
+        'skyscanner.com': { name: 'Skyscanner', type: 'aggregator' },
+        'trip.com': { name: 'Trip.com', type: 'aggregator' },
+        'carrentals.com': { name: 'CarRentals.com', type: 'aggregator' },
+        'rentalcars.com': { name: 'RentalCars.com', type: 'aggregator' },
+        'stressfreecarrental.com': { name: 'StressFree', type: 'aggregator' },
+        'happycar.com': { name: 'HappyCar', type: 'aggregator' },
+        'enterprise.com': { name: 'Enterprise', type: 'direct' },
+        'hertz.com': { name: 'Hertz', type: 'direct' },
+        'avis.com': { name: 'Avis', type: 'direct' },
+        'budget.com': { name: 'Budget', type: 'direct' },
+        'turo.com': { name: 'Turo', type: 'direct' },
+        'sixt.com': { name: 'Sixt', type: 'direct' },
+        'nationalcar.com': { name: 'National', type: 'direct' },
+        'alamo.com': { name: 'Alamo', type: 'direct' },
+        'costcotravel.com': { name: 'Costco Travel', type: 'direct' },
+        'expedia.com': { name: 'Expedia', type: 'aggregator' },
+    };
+    const getSiteInfo = (url) => {
+        try {
+            const hostname = new URL(url).hostname.replace('www.', '');
+            for (const [domain, info] of Object.entries(RENTAL_SITES)) {
+                if (hostname === domain || hostname.endsWith('.' + domain)) {
+                    return { company: info.name, siteType: info.type };
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    };
+    // Deduplicate by company — keep the most location-specific URL per company
+    const seen = new Map();
+    for (const r of rentalResults) {
+        const siteInfo = getSiteInfo(r.url);
+        if (!siteInfo)
+            continue;
+        const existing = seen.get(siteInfo.company);
+        // Prefer URLs that mention the location (more specific = better)
+        const locLower = (location || '').toLowerCase().replace(/\s+/g, '');
+        const urlLower = r.url.toLowerCase().replace(/[\s-]/g, '');
+        const isLocationSpecific = locLower && urlLower.includes(locLower.substring(0, 5));
+        if (!existing || isLocationSpecific) {
+            seen.set(siteInfo.company, r);
+        }
+    }
+    const listings = [...seen.entries()]
+        .map(([company, r]) => {
+        const siteInfo = getSiteInfo(r.url);
+        // Extract price from BOTH title and snippet; prefer title (more prominent = more accurate)
+        const titlePrice = parsePrice(r.title || '');
+        const snippetPrice = parsePrice(r.snippet || '');
+        const price = titlePrice || snippetPrice;
+        const priceValue = extractPriceValue(price);
+        return {
+            name: r.title?.replace(/\s*[-|–—].*$/, '').trim() || `${company} Car Rental`,
+            company,
+            siteType: siteInfo.siteType,
+            url: addAffiliateTag(r.url),
+            snippet: r.snippet || '',
+            price,
+            priceValue,
+        };
+    });
+    // Sort: aggregators with prices first (lowest price first), then aggregators without prices, then direct providers
+    listings.sort((a, b) => {
+        const aVal = a.priceValue ?? Infinity;
+        const bVal = b.priceValue ?? Infinity;
+        if (aVal !== bVal)
+            return aVal - bVal;
+        if (a.siteType !== b.siteType)
+            return a.siteType === 'aggregator' ? -1 : 1;
+        return 0;
+    });
+    const topListings = listings.slice(0, 6);
+    // Also add direct booking links for major providers if they didn't appear in search
+    const searchLocation = encodeURIComponent(location || 'New York');
+    const directLinks = [
+        { company: 'Kayak', siteType: 'aggregator', url: `https://www.kayak.com/cars/${searchLocation}`, name: 'Compare all rental companies' },
+        { company: 'Enterprise', siteType: 'direct', url: `https://www.enterprise.com/en/car-rental/locations/us.html`, name: 'Enterprise Rent-A-Car' },
+        { company: 'Hertz', siteType: 'direct', url: `https://www.hertz.com/rentacar/reservation/`, name: 'Hertz Car Rental' },
+        { company: 'Avis', siteType: 'direct', url: `https://www.avis.com/en/home`, name: 'Avis Car Rental' },
+        { company: 'Budget', siteType: 'direct', url: `https://www.budget.com/en/home`, name: 'Budget Car Rental' },
+    ].filter(d => !topListings.some(l => l.company === d.company));
+    const allListings = [
+        ...topListings,
+        ...directLinks.map(d => ({ ...d, snippet: '', price: undefined, priceValue: undefined })),
+    ];
+    // Build markdown content
+    const content = `# 🔑 Car Rentals${location ? ` — ${location}` : ''}${dates ? ` (${dates.from} to ${dates.to})` : ''}\n\n` +
+        allListings.map((l, i) => `${i + 1}. **${l.name}** — ${l.company}${l.price ? ` · ${l.price}/day` : ''}${l.siteType === 'aggregator' ? ' *(compares prices)*' : ''}\n   ${l.snippet}`).join('\n\n');
+    // AI synthesis: use extracted prices + Reddit tips
+    let answer;
+    if (process.env.OLLAMA_URL) {
+        const priceInfo = allListings.filter(l => l.price).map(l => `${l.company}: ${l.price}/day`).join(', ');
+        const redditContent = redditResults.slice(0, 3).map(r => `${r.title}: ${r.snippet || ''}`).join('\n');
+        const aiPrompt = `${PROMPT_INJECTION_DEFENSE}You are a car rental advisor. ONLY use information from the sources below. User wants to rent a car${location ? ' in ' + location : ''}.${dates ? ` Dates: ${dates.from} to ${dates.to}.` : ''}${budget ? ` Budget: $${budget}/day.` : ''} Prices found: ${priceInfo || 'no prices extracted yet — refer to sites below'}. Reddit tips: ${redditContent || 'none'}. Give a 2-3 sentence recommendation based ONLY on sources. Mention the cheapest option and actual price. Max 200 words. Cite sources inline as [1], [2], [3].`;
+        const aiText = await callLLMQuick(aiPrompt, { maxTokens: 250, timeoutMs: 5000, temperature: 0.4 });
+        if (aiText && aiText.length > 20)
+            answer = aiText;
+    }
+    return {
+        type: 'rental',
+        source: 'Car Rentals + Reddit',
+        sourceUrl: `https://www.kayak.com/cars/${searchLocation}`,
+        content,
+        title: `Car Rentals${location ? ` in ${location}` : ''}`,
+        structured: { listings: allListings },
+        tokens: content.split(/\s+/).length,
+        fetchTimeMs: Date.now() - t0,
+        loadingMessage: 'Searching for rental cars...',
+        ...(answer !== undefined ? { answer } : {}),
+        sources: [
+            { type: 'rental', count: topListings.length },
+            { type: 'reddit', threads: redditResults.slice(0, 3).map(r => ({ title: r.title, url: r.url, snippet: r.snippet })) },
+        ],
+    };
+}
+// ─── Restaurant source fetchers ───────────────────────────────────────────

package/dist/server/routes/smart-search/handlers/restaurants.d.ts

@@ -0,0 +1,2 @@
+import type { SearchIntent, SmartSearchResult } from '../types.js';
+export declare function handleRestaurantSearch(intent: SearchIntent, requestLanguage?: string): Promise<SmartSearchResult>;

package/dist/server/routes/smart-search/handlers/restaurants.js

@@ -0,0 +1,205 @@
+import { localSearch } from '../../../../core/local-search.js';
+import { callLLMQuick, sanitizeSearchQuery, PROMPT_INJECTION_DEFENSE } from '../llm.js';
+import { fetchYelpResults } from '../sources/yelp.js';
+import { fetchRedditResults } from '../sources/reddit.js';
+import { fetchYouTubeResults } from '../sources/youtube.js';
+export async function handleRestaurantSearch(intent, requestLanguage) {
+    const t0 = Date.now();
+    const location = intent.params.location || 'New York, NY';
+    const keyword = intent.query
+        .replace(/\b(best|top|good|cheap|affordable|near me|near|around|in|find|search|looking for)\b/gi, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    // ── Run ALL data sources in parallel for speed ──────────────────────────
+    // Previously sequential: localSearch → Yelp → Reddit+YouTube = 20-30s
+    // Now parallel: everything races at once = 8-10s max
+    const hasPlacesKey = !!process.env.GOOGLE_PLACES_API_KEY;
+    const [localSearchSettled, yelpSettled, redditSettled, youtubeSettled] = await Promise.allSettled([
+        // Google Places (primary when key available)
+        hasPlacesKey
+            ? Promise.race([
+                localSearch({ query: keyword || intent.query, location, language: requestLanguage, limit: 10 }),
+                new Promise((_, rej) => setTimeout(() => rej(new Error('local search timeout')), 8000)),
+            ])
+            : Promise.resolve(null),
+        // Yelp (secondary / fallback)
+        Promise.race([
+            fetchYelpResults(keyword, location).then(v => v),
+            new Promise((_, rej) => setTimeout(() => rej(new Error('yelp timeout')), 8000)),
+        ]),
+        // Reddit (best-effort supplementary)
+        Promise.race([
+            fetchRedditResults(keyword, location),
+            new Promise((_, rej) => setTimeout(() => rej(new Error('reddit timeout')), 6000)),
+        ]),
+        // YouTube (best-effort supplementary)
+        Promise.race([
+            fetchYouTubeResults(keyword, location),
+            new Promise((_, rej) => setTimeout(() => rej(new Error('youtube timeout')), 5000)),
+        ]),
+    ]);
+    const googlePlacesData = localSearchSettled.status === 'fulfilled' ? localSearchSettled.value : null;
+    if (googlePlacesData && googlePlacesData.results?.length > 0) {
+        console.log(`[smart-search] localSearch() returned ${googlePlacesData.results.length} results from ${googlePlacesData.source}`);
+    }
+    // Skip Yelp data if Google Places already has enough results
+    const skipYelp = googlePlacesData && googlePlacesData.results?.length >= 5;
+    const yelpData = (!skipYelp && yelpSettled.status === 'fulfilled') ? yelpSettled.value : null;
+    const redditData = redditSettled.status === 'fulfilled' ? redditSettled.value : null;
+    const youtubeData = youtubeSettled.status === 'fulfilled' ? youtubeSettled.value : null;
+    // Re-rank: composite score = rating * log2(reviewCount + 1)
+    // This naturally surfaces high-rated places with meaningful review volume
+    if (yelpData && yelpData.businesses.length > 0) {
+        yelpData.businesses.sort((a, b) => {
+            const scoreA = (a.rating || 0) * Math.log2((a.reviewCount || 0) + 1);
+            const scoreB = (b.rating || 0) * Math.log2((b.reviewCount || 0) + 1);
+            return scoreB - scoreA;
+        });
+        // For "best" queries, filter to minimum 50 reviews
+        const isBestQuery = /\b(best|top|highest rated)\b/i.test(intent.query);
+        if (isBestQuery) {
+            const filtered = yelpData.businesses.filter((b) => (b.reviewCount || 0) >= 50);
+            if (filtered.length >= 3) {
+                yelpData.businesses = filtered;
+            }
+        }
+        // Remove permanently closed businesses
+        yelpData.businesses = yelpData.businesses.filter((b) => !b.isClosed);
+    }
+    // ── Build markdown content from all sources ──────────────────────────
+    const contentParts = [];
+    // Google Places section (shown first when available — higher quality data)
+    if (googlePlacesData && googlePlacesData.results.length > 0) {
+        const priceLevelStr = (lvl) => lvl !== undefined ? '$'.repeat(Math.max(1, lvl)) : '';
+        contentParts.push(`## Google Places (${googlePlacesData.results.length} results)`);
+        googlePlacesData.results.slice(0, 10).forEach((b, i) => {
+            const name = b.name || 'Unknown';
+            const rating = b.rating ? `⭐${b.rating}` : '';
+            const reviews = b.reviewCount ? `(${b.reviewCount.toLocaleString()} reviews)` : '';
+            const price = b.priceLevel !== undefined ? ` · ${priceLevelStr(b.priceLevel)}` : '';
+            const openStatus = b.isOpen === true ? ' · 🟢 Open Now' : (b.isOpen === false ? ' · 🔴 Closed' : '');
+            const todayHours = b.hours?.length > 0 ? ` · 🕐 ${b.hours[0]}` : '';
+            const mapsLink = b.googleMapsUrl ? ` · [📍 Maps](${b.googleMapsUrl})` : '';
+            const addr = b.address || '';
+            contentParts.push(`${i + 1}. **${name}** ${rating} ${reviews}${price}${openStatus}${todayHours}${mapsLink}${addr ? ` — ${addr}` : ''}`);
+        });
+        contentParts.push('');
+    }
+    // Yelp section
+    if (yelpData) {
+        const businesses = yelpData.businesses;
+        if (businesses.length > 0) {
+            contentParts.push(`## Yelp (${businesses.length} restaurants)`);
+            businesses.slice(0, 10).forEach((b, i) => {
+                const name = b.name || b.title || 'Unknown';
+                const rating = b.rating ? `⭐${b.rating}` : '';
+                const reviews = b.reviewCount ? `(${b.reviewCount.toLocaleString()} reviews)` : '';
+                const address = b.address || b.location || '';
+                const price = b.price ? ` · ${b.price}` : '';
+                const openStatus = b.isClosed ? ' · ⛔ Permanently Closed' : (b.isOpenNow ? ' · 🟢 Open Now' : ' · 🔴 Closed');
+                const todayHours = b.todayHours && b.todayHours !== 'Closed today' ? ` · 🕐 ${b.todayHours}` : (b.todayHours === 'Closed today' ? ' · 🕐 Closed today' : '');
+                const txns = b.transactions?.length > 0 ? ` · ${b.transactions.map((t) => t === 'delivery' ? '🚗 Delivery' : t === 'pickup' ? '📦 Pickup' : t).join(' ')}` : '';
+                const mapsLink = b.googleMapsUrl ? ` · [📍 Google Maps](${b.googleMapsUrl})` : '';
+                contentParts.push(`${i + 1}. **${name}** ${rating} ${reviews}${price}${openStatus}${todayHours}${txns}${mapsLink}${address ? ` — ${address}` : ''}`);
+            });
+        }
+        else if (yelpData.content) {
+            contentParts.push(`## Yelp\n${yelpData.content.substring(0, 800)}`);
+        }
+    }
+    // Reddit section
+    if (redditData) {
+        contentParts.push('');
+        contentParts.push('## Reddit Recommendations');
+        if (redditData.thread) {
+            contentParts.push(`**${redditData.thread.title}**`);
+            if (redditData.thread.content) {
+                contentParts.push(redditData.thread.content.substring(0, 600));
+            }
+        }
+        if (redditData.otherThreads.length > 0) {
+            contentParts.push('');
+            redditData.otherThreads.slice(0, 3).forEach(t => {
+                contentParts.push(`- [${t.title}](${t.url}) — ${t.snippet || ''}`);
+            });
+        }
+    }
+    // YouTube section
+    if (youtubeData && youtubeData.videos.length > 0) {
+        contentParts.push('');
+        contentParts.push('## YouTube Reviews');
+        youtubeData.videos.forEach(v => {
+            contentParts.push(`🎬 [${v.title}](${v.url}) — ${v.snippet || ''}`);
+        });
+    }
+    const combinedContent = contentParts.join('\n');
+    // ── Build sources array for dashboard tabs ────────────────────────────
+    const sources = [];
+    if (googlePlacesData)
+        sources.push({ title: 'Google Places', url: `https://maps.google.com/?q=${encodeURIComponent(keyword + ' ' + location)}`, domain: 'google.com' });
+    if (yelpData)
+        sources.push({ title: 'Yelp', url: yelpData.url, domain: 'yelp.com' });
+    if (redditData?.thread)
+        sources.push({ title: redditData.thread.title, url: redditData.thread.url, domain: 'reddit.com' });
+    if (youtubeData?.videos[0])
+        sources.push({ title: youtubeData.videos[0].title, url: youtubeData.videos[0].url, domain: 'youtube.com' });
+    // ── AI Synthesis via Qwen/Ollama (optional) ───────────────────────────
+    // Build a Yelp-only summary first (fast, doesn't wait for Reddit)
+    // then enrich with Reddit/YouTube if they arrived
+    let answer;
+    const ollamaUrl = process.env.OLLAMA_URL;
+    if (ollamaUrl && yelpData && yelpData.businesses.length > 0) {
+        try {
+            const yelpLines = yelpData.businesses.slice(0, 3).map((b, i) => {
+                const openStatus = b.isClosed ? 'PERMANENTLY CLOSED' : (b.isOpenNow ? 'OPEN NOW' : 'Closed right now');
+                const txns = b.transactions?.length > 0 ? `Available: ${b.transactions.join(', ')}` : '';
+                const googleInfo = b.googleRating ? ` | Google: ⭐${b.googleRating} (${b.googleReviewCount} reviews)` : '';
+                return `[${i + 1}] ${b.name} ⭐${b.rating} (${b.reviewCount?.toLocaleString()} reviews) ${b.price || ''} — ${b.address}
+   ${openStatus} | Today: ${b.todayHours || 'hours not available'} | ${txns} | Categories: ${b.categories || ''}${googleInfo}
+   URL: ${b.url || ''}`;
+            }).join('\n');
+            const yelpCitations = yelpData.businesses.slice(0, 3).map((b, i) => `[${i + 1}] ${b.url || 'yelp.com'}`).join('\n');
+            const redditHint = redditData?.otherThreads?.slice(0, 2).map((t) => t.title).join('; ') || '';
+            const systemPrompt = `${PROMPT_INJECTION_DEFENSE}Recommend top 3 restaurants. For each: name with inline citation [1][2][3], why it's good, open/closed status, hours.
+Cite sources inline using [1], [2], [3] notation matching the numbered sources. At the end, list Sources with their URLs.
+Be specific. Max 200 words.
+`;
+            const userMessage = `Query: ${sanitizeSearchQuery(intent.query)}\n\nTop restaurants:\n${yelpLines}${redditHint ? '\n\nReddit mentions: ' + redditHint : ''}\n\nSources:\n${yelpCitations}`;
+            const text = await callLLMQuick(`${systemPrompt}\n\n${userMessage}`, { maxTokens: 250, timeoutMs: 5000, temperature: 0.3 });
+            if (text)
+                answer = text;
+        }
+        catch (err) {
+            console.warn('[restaurant-search] LLM synthesis failed (graceful fallback):', err.message);
+        }
+    }
+    // If ALL sources completely failed, surface an error
+    if (!googlePlacesData && !yelpData && !redditData && !youtubeData) {
+        throw new Error('All restaurant sources failed');
+    }
+    const yelpUrl = yelpData?.url || `https://www.yelp.com/search?find_desc=${encodeURIComponent(keyword)}&find_loc=${encodeURIComponent(location)}`;
+    // Build source label based on what we actually used
+    const sourceLabel = [
+        googlePlacesData ? 'Google Places' : null,
+        yelpData ? 'Yelp' : null,
+        redditData ? 'Reddit' : null,
+        youtubeData ? 'YouTube' : null,
+    ].filter(Boolean).join(' + ') || 'Yelp + Reddit + YouTube';
+    // Merge structured data: prefer Google Places, fall back to Yelp
+    const structuredData = googlePlacesData
+        ? { businesses: googlePlacesData.results, googlePlaces: true }
+        : yelpData?.domainData?.structured;
+    return {
+        type: 'restaurants',
+        source: sourceLabel,
+        sourceUrl: yelpUrl,
+        content: combinedContent,
+        title: `${keyword} in ${location}`,
+        domainData: googlePlacesData ? { structured: structuredData } : yelpData?.domainData,
+        structured: structuredData,
+        tokens: combinedContent.split(/\s+/).length,
+        fetchTimeMs: Date.now() - t0,
+        ...(answer !== undefined ? { answer } : {}),
+        ...(sources.length > 0 ? { sources } : {}),
+    };
+}

package/dist/server/routes/smart-search/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Smart Search endpoint — intent detection + travel/commerce routing
+ * POST /v1/search/smart
+ *
+ * Detects user intent from natural language and routes to the best source:
+ * - cars       → Cars.com with browser rendering + structured extraction
+ * - flights    → Google Flights with browser rendering + flight extractor
+ * - hotels     → Google Hotels with browser rendering
+ * - rental     → Kayak with browser rendering + rental extractor
+ * - restaurants → Yelp Fusion API extractor
+ * - products   → Amazon search with structured extraction
+ * - general    → SearXNG with smart enrichment (peel() for top 3)
+ */
+import { Router } from 'express';
+import '../../types.js';
+import { AuthStore } from '../../auth-store.js';
+export type { SearchIntent, SmartSearchResult } from './types.js';
+export { detectSearchIntent } from './intent.js';
+export declare function createSmartSearchRouter(authStore: AuthStore): Router;