@iflow-mcp/jakeliume-webpeel 0.22.0

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,154 @@
+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;
+    try {
+        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: 8000, temperature: 0.3 });
+        if (aiText && aiText.length > 20)
+            answer = aiText;
+    }
+    catch (err) {
+        console.warn('[rental-search] LLM synthesis failed (graceful fallback):', err.message);
+    }
+    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,225 @@
+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 (uses Groq/OpenAI/Glama/Ollama — callLLMQuick picks best) ──
+    // Uses whichever data source returned results: Google Places OR Yelp
+    // NOTE: K8s OLLAMA_URL is port 11435 but Ollama runs on 11434 — fix in K8s secrets
+    let answer;
+    // Build restaurant lines from whichever source has data
+    const hasGoogleData = googlePlacesData && googlePlacesData.results?.length > 0;
+    const hasYelpData = yelpData && yelpData.businesses?.length > 0;
+    if (hasGoogleData || hasYelpData) {
+        try {
+            let restaurantLines;
+            let citations;
+            if (hasGoogleData) {
+                // Format Google Places results for LLM
+                const priceLevelStr = (lvl) => lvl !== undefined ? '$'.repeat(Math.max(1, lvl)) : '';
+                restaurantLines = googlePlacesData.results.slice(0, 3).map((b, i) => {
+                    const openStatus = b.isOpen === true ? 'OPEN NOW' : (b.isOpen === false ? 'Closed right now' : 'hours unknown');
+                    const hours = b.hours?.length > 0 ? b.hours[0] : 'not available';
+                    const price = b.priceLevel !== undefined ? priceLevelStr(b.priceLevel) : '';
+                    return `[${i + 1}] ${b.name} ⭐${b.rating || '?'} (${(b.reviewCount || 0).toLocaleString()} reviews) ${price} — ${b.address || ''}
+   ${openStatus} | Today: ${hours} | Categories: ${b.categories || b.types?.join(', ') || ''}
+   URL: ${b.googleMapsUrl || 'google.com/maps'}`;
+                }).join('\n');
+                citations = googlePlacesData.results.slice(0, 3).map((b, i) => `[${i + 1}] ${b.googleMapsUrl || 'google.com/maps'}`).join('\n');
+            }
+            else {
+                // Format Yelp results for LLM
+                restaurantLines = 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');
+                citations = 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${restaurantLines}${redditHint ? '\n\nReddit mentions: ' + redditHint : ''}\n\nSources:\n${citations}`;
+            const text = await callLLMQuick(`${systemPrompt}\n\n${userMessage}`, { maxTokens: 250, timeoutMs: 8000, 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/handlers/transit-verdict.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Transit Verdict Builder
+ *
+ * Extracts structured pricing data from search results and peeled transit
+ * booking pages, then produces a TransactionalVerdict that the UI can render
+ * directly — no markdown parsing needed.
+ *
+ * Design principles:
+ *  1. Only use prices found in real source data (never fabricate).
+ *  2. Prefer booking/comparison sites (wanderu, flixbus, busbud, rome2rio,
+ *     greyhound, amtrak) over generic snippets.
+ *  3. Deduplicate by provider+price so the UI gets clean data.
+ *  4. Return round-trip totals only when both legs have real data.
+ */
+import type { TransactionalVerdict } from '../types.js';
+export interface TransitSourceResult {
+    url: string;
+    domain: string;
+    title: string;
+    content: string;
+    snippet: string;
+    isTransitSource?: boolean;
+    legHint?: 'outbound' | 'return' | 'unknown';
+}
+export interface BuildTransitVerdictInput {
+    query: string;
+    transitSources: TransitSourceResult[];
+    parsedQuery: {
+        origin: string;
+        destination: string;
+        departDate: string;
+        returnDate: string;
+        isRoundTrip: boolean;
+        mode: string;
+    };
+}
+/**
+ * Build a TransactionalVerdict from transit search results.
+ * Returns null if no usable prices were found.
+ */
+export declare function buildTransitVerdict(input: BuildTransitVerdictInput): TransactionalVerdict | null;

package/dist/server/routes/smart-search/handlers/transit-verdict.js

@@ -0,0 +1,224 @@
+/**
+ * Transit Verdict Builder
+ *
+ * Extracts structured pricing data from search results and peeled transit
+ * booking pages, then produces a TransactionalVerdict that the UI can render
+ * directly — no markdown parsing needed.
+ *
+ * Design principles:
+ *  1. Only use prices found in real source data (never fabricate).
+ *  2. Prefer booking/comparison sites (wanderu, flixbus, busbud, rome2rio,
+ *     greyhound, amtrak) over generic snippets.
+ *  3. Deduplicate by provider+price so the UI gets clean data.
+ *  4. Return round-trip totals only when both legs have real data.
+ */
+/** Known booking domains — results from these are higher-trust for pricing */
+const BOOKING_DOMAINS = new Set([
+    'wanderu.com', 'flixbus.com', 'greyhound.com', 'busbud.com',
+    'amtrak.com', 'rome2rio.com', 'megabus.com', 'ourbus.com',
+    'gotobus.com', 'trailways.com', 'peterpanbus.com', 'coachrun.com',
+]);
+/** Provider name normalization map */
+const PROVIDER_NAMES = {
+    flixbus: 'FlixBus',
+    greyhound: 'Greyhound',
+    megabus: 'Megabus',
+    amtrak: 'Amtrak',
+    ourbus: 'OurBus',
+    wanderu: 'Wanderu',
+    busbud: 'Busbud',
+    rome2rio: 'Rome2Rio',
+    peterpanbus: 'Peter Pan Bus',
+    peterpan: 'Peter Pan Bus',
+    gotobus: 'GotoBus',
+    coachrun: 'CoachRun',
+    trailways: 'Trailways',
+    boltbus: 'BoltBus',
+    vamoose: 'Vamoose',
+};
+/**
+ * Extract price-provider pairs from a transit source page.
+ *
+ * Tries multiple heuristics:
+ *  1. "$XX on Provider" / "Provider from $XX" / "Provider: $XX"
+ *  2. Lines with a known provider name + a dollar amount
+ *  3. Plain dollar amounts with domain-based provider attribution
+ */
+function extractPricesFromSource(source, leg) {
+    const prices = [];
+    const text = `${source.title} ${source.snippet} ${source.content}`;
+    const isBooking = BOOKING_DOMAINS.has(source.domain);
+    // Guess provider from domain
+    const domainProvider = source.domain.replace(/\.com$|\.net$|\.org$/, '');
+    const fallbackProvider = PROVIDER_NAMES[domainProvider] || titleCase(domainProvider);
+    // ── Strategy 1: "$XX … provider" or "provider … $XX" patterns ──
+    // Match lines like: "FlixBus from $19.99" or "$19 on Greyhound"
+    const providerKeys = Object.keys(PROVIDER_NAMES).join('|');
+    const providerPriceRe = new RegExp(`(?:(${providerKeys})[^$]{0,30}\\$(\\d+(?:\\.\\d{1,2})?))|(?:\\$(\\d+(?:\\.\\d{1,2})?)[^\\n]{0,30}(${providerKeys}))`, 'gi');
+    let m;
+    while ((m = providerPriceRe.exec(text)) !== null) {
+        const providerKey = (m[1] || m[4] || '').toLowerCase();
+        const priceStr = m[2] || m[3];
+        const price = parseFloat(priceStr);
+        if (price > 0 && price < 1000 && PROVIDER_NAMES[providerKey]) {
+            prices.push({
+                provider: PROVIDER_NAMES[providerKey],
+                price,
+                currency: 'USD',
+                url: source.url,
+                isBookingSite: isBooking,
+                leg,
+            });
+        }
+    }
+    // ── Strategy 2: Plain dollar amounts — attribute to domain provider ──
+    if (prices.length === 0) {
+        const plainPrices = text.match(/\$(\d+(?:\.\d{1,2})?)/g);
+        if (plainPrices) {
+            for (const raw of plainPrices) {
+                const price = parseFloat(raw.replace('$', ''));
+                if (price > 0 && price < 1000) {
+                    prices.push({
+                        provider: fallbackProvider,
+                        price,
+                        currency: 'USD',
+                        url: source.url,
+                        isBookingSite: isBooking,
+                        leg,
+                    });
+                }
+            }
+        }
+    }
+    return prices;
+}
+function titleCase(s) {
+    return s
+        .split(/\s+/)
+        .filter(Boolean)
+        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(' ');
+}
+/**
+ * Deduplicate prices: keep lowest price per provider.
+ */
+function dedup(prices) {
+    const map = new Map();
+    for (const p of prices) {
+        const key = `${p.provider.toLowerCase()}|${p.leg}`;
+        const existing = map.get(key);
+        if (!existing || p.price < existing.price) {
+            map.set(key, p);
+        }
+    }
+    return [...map.values()].sort((a, b) => a.price - b.price);
+}
+/**
+ * Build a TransactionalVerdict from transit search results.
+ * Returns null if no usable prices were found.
+ */
+export function buildTransitVerdict(input) {
+    const { transitSources, parsedQuery } = input;
+    const { origin, destination, isRoundTrip, mode, departDate, returnDate } = parsedQuery;
+    if (transitSources.length === 0)
+        return null;
+    // ── Extract prices from all sources ──
+    const allPrices = [];
+    for (const src of transitSources) {
+        // Determine leg: if the source URL/content suggests a return route, tag it
+        const isReturnLeg = src.legHint === 'return' || (origin && destination &&
+            (src.content.toLowerCase().includes(`${destination.toLowerCase()} to ${origin.toLowerCase()}`) ||
+                src.title.toLowerCase().includes(`${destination.toLowerCase()} to ${origin.toLowerCase()}`)));
+        const leg = src.legHint || (isReturnLeg ? 'return' : (origin && destination ? 'outbound' : 'unknown'));
+        allPrices.push(...extractPricesFromSource(src, leg));
+    }
+    if (allPrices.length === 0)
+        return null;
+    // ── Deduplicate ──
+    const uniquePrices = dedup(allPrices);
+    // ── Separate by leg ──
+    const outbound = uniquePrices.filter(p => p.leg === 'outbound' || p.leg === 'unknown');
+    const returnLeg = uniquePrices.filter(p => p.leg === 'return');
+    // ── Build options ──
+    const toOption = (p) => ({
+        provider: p.provider,
+        price: p.price,
+        currency: p.currency,
+        route: origin && destination
+            ? `${titleCase(origin)} → ${titleCase(destination)}`
+            : undefined,
+        url: p.url,
+        notes: p.isBookingSite ? 'Booking site' : 'Price from search results',
+    });
+    // Best = cheapest from booking sites, else cheapest overall
+    const bookingPrices = outbound.filter(p => p.isBookingSite);
+    const best = bookingPrices.length > 0 ? bookingPrices[0] : outbound[0];
+    if (!best)
+        return null;
+    const bestOption = toOption(best);
+    const maxReasonableAltPrice = Math.max(best.price * 3, best.price + 75);
+    const alternatives = outbound
+        .filter(p => !(p.provider === best.provider && p.price === best.price))
+        .filter(p => p.price <= maxReasonableAltPrice)
+        .slice(0, 5)
+        .map(toOption);
+    // ── Route label ──
+    const routeLabel = origin && destination
+        ? `${titleCase(origin)} → ${titleCase(destination)}`
+        : 'this route';
+    // ── Headline ──
+    const headline = `Cheapest I found is $${best.price.toFixed(2)} on ${best.provider} for ${routeLabel}`;
+    // ── Totals ──
+    let totals;
+    if (isRoundTrip) {
+        const returnBest = returnLeg.length > 0
+            ? returnLeg[0]
+            : null;
+        totals = {
+            oneWayLowest: best.price,
+            currency: 'USD',
+        };
+        if (returnBest) {
+            totals.returnLowest = returnBest.price;
+            totals.roundTripLowest = best.price + returnBest.price;
+        }
+    }
+    // ── Confidence ──
+    const bookingSourceCount = new Set(uniquePrices.filter(p => p.isBookingSite).map(p => p.provider.toLowerCase())).size;
+    let confidence = 'LOW';
+    if (bookingSourceCount >= 2 && uniquePrices.length >= 3) {
+        confidence = 'HIGH';
+    }
+    else if (bookingSourceCount >= 1 || uniquePrices.length >= 2) {
+        confidence = 'MEDIUM';
+    }
+    // ── Caveats ──
+    const caveats = [];
+    caveats.push('Prices may vary by date and availability. Book directly for confirmed pricing.');
+    if (!departDate) {
+        caveats.push('No specific date detected — prices shown are general/representative.');
+    }
+    if (isRoundTrip && returnLeg.length === 0) {
+        caveats.push('Could not find separate return leg pricing. Round-trip total unavailable.');
+    }
+    if (bookingSourceCount === 0) {
+        caveats.push('No booking site prices found — prices extracted from search snippets only.');
+    }
+    return {
+        vertical: 'transit',
+        headline,
+        confidence,
+        bestOption,
+        alternatives,
+        ...(totals ? { totals } : {}),
+        caveats,
+        query: {
+            origin: origin || undefined,
+            destination: destination || undefined,
+            departDate: departDate || undefined,
+            returnDate: returnDate || undefined,
+            isRoundTrip,
+            mode,
+        },
+    };
+}