llm-search-tools 1.1.0

package/dist/modules/scrapers/google.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAnswerBox = extractAnswerBox;
+exports.searchGoogle = searchGoogle;
+const google_sr_1 = require("google-sr");
+const common_1 = require("../common");
+/**
+ * Extracts the "Answer Box" or "Featured Snippet" from the Google Search DOM
+ */
+function extractAnswerBox(doc) {
+    // 1. Featured Snippet (Text) - .hgKElc
+    const featuredSnippet = doc.querySelector(".hgKElc");
+    if (featuredSnippet && featuredSnippet.textContent) {
+        return featuredSnippet.textContent.trim();
+    }
+    // 2. Featured Snippet (List) - .LGOjhe
+    const listSnippet = doc.querySelector(".LGOjhe");
+    if (listSnippet && listSnippet.textContent) {
+        return listSnippet.textContent.trim();
+    }
+    // 3. Direct Answer (e.g., calculations, dates) - .Z0LcW
+    const directAnswer = doc.querySelector(".Z0LcW");
+    if (directAnswer && directAnswer.textContent) {
+        return directAnswer.textContent.trim();
+    }
+    // 4. Knowledge Panel Description - .kno-rdesc span
+    const knowledgePanel = doc.querySelector(".kno-rdesc span");
+    if (knowledgePanel && knowledgePanel.textContent) {
+        return knowledgePanel.textContent.trim();
+    }
+    // 5. Dictionary Definition - div[data-attrid="description"]
+    const definition = doc.querySelector("div[data-attrid='description']");
+    if (definition && definition.textContent) {
+        return definition.textContent.trim();
+    }
+    return undefined;
+}
+// Rate limiting parameters
+const GOOGLE_DELAY = 2000; // 2 seconds for Google
+let lastGoogleSearchTime = 0;
+// Cache for search results
+const searchCache = new Map();
+const CACHE_TTL = 60 * 60 * 1000; // 1 hour
+// Helper function to enforce rate limiting
+async function enforceRateLimit() {
+    const now = Date.now();
+    const timeSinceLastSearch = now - lastGoogleSearchTime;
+    if (timeSinceLastSearch < GOOGLE_DELAY) {
+        await new Promise((resolve) => setTimeout(resolve, GOOGLE_DELAY - timeSinceLastSearch));
+    }
+    lastGoogleSearchTime = Date.now();
+}
+// Search using Puppeteer
+async function searchWithPuppeteer(query, options) {
+    const proxy = (0, common_1.parseProxyConfig)(options.proxy);
+    const browser = await (0, common_1.createStealthBrowser)(proxy || undefined);
+    const page = await browser.newPage();
+    try {
+        // Set realistic viewport
+        await page.setViewport({ width: 1920, height: 1080 });
+        // Set extra headers
+        await page.setExtraHTTPHeaders((0, common_1.createRealisticHeaders)());
+        if (options.category === "images") {
+            const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(query)}&tbm=isch`;
+            await page.goto(searchUrl, { waitUntil: "networkidle2" });
+            // Wait for image results
+            // Google images usually have div.isv-r or specific containers
+            try {
+                await page.waitForSelector("div[data-id], div.isv-r", { timeout: 10000 });
+            }
+            catch (e) {
+                // continue, might be empty
+            }
+            const results = await page.evaluate((limit) => {
+                const items = [];
+                // Select image containers
+                const elements = document.querySelectorAll("div[data-id], div.isv-r");
+                for (let i = 0; i < Math.min(elements.length, limit || 20); i++) {
+                    const el = elements[i];
+                    // Title often in h3 or aria-label
+                    const titleEl = el.querySelector("h3") || el.querySelector("[title]");
+                    const title = titleEl?.textContent || titleEl?.getAttribute("title") || "Image";
+                    // Source link (page containing image)
+                    const linkEl = el.querySelector("a");
+                    const url = linkEl?.href || "";
+                    // Thumbnail
+                    const imgEl = el.querySelector("img");
+                    const thumbnailUrl = imgEl?.src || imgEl?.getAttribute("data-src") || "";
+                    // Full image URL is hard to get without clicking.
+                    // Sometimes it's in a JSON blob in the page, but that's brittle.
+                    // We will use the thumbnail as a fallback for imageUrl if we can't find better.
+                    // For now, let's just use the thumbnail.
+                    if (url && thumbnailUrl) {
+                        items.push({
+                            title,
+                            url, // This is the source page URL
+                            snippet: title,
+                            imageUrl: thumbnailUrl, // Using thumbnail as image URL for now due to complexity
+                            thumbnailUrl,
+                            source: "google-images",
+                        });
+                    }
+                }
+                return items;
+            }, options.limit);
+            return results;
+        }
+        // Default Web Search
+        const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(query)}`;
+        await page.goto(searchUrl, { waitUntil: "networkidle2" });
+        // Wait for results
+        await page.waitForSelector("div.g", { timeout: 10000 });
+        // Extract results
+        const results = await page.evaluate((limit) => {
+            const items = [];
+            const elements = document.querySelectorAll("div.g");
+            for (let i = 0; i < Math.min(elements.length, limit || 10); i++) {
+                const el = elements[i];
+                const titleEl = el.querySelector("h3");
+                const linkEl = el.querySelector("a");
+                const snippetEl = el.querySelector(".VwiC3b");
+                if (titleEl && linkEl) {
+                    items.push({
+                        title: titleEl.textContent || "",
+                        url: linkEl.href || "",
+                        snippet: snippetEl?.textContent || "",
+                        source: "google",
+                    });
+                }
+            }
+            return items;
+        }, options.limit);
+        return results;
+    }
+    finally {
+        await browser.close();
+    }
+}
+async function searchGoogle(query, options = {}) {
+    try {
+        // Clone and merge options
+        const mergedOptions = {
+            limit: 10,
+            safeSearch: true,
+            timeout: 10000,
+            forcePuppeteer: false,
+            antiBot: {
+                enabled: true,
+                maxRetries: 3,
+                retryDelay: 2000,
+            },
+            ...options,
+        };
+        const cacheKey = (0, common_1.getCacheKey)(query, mergedOptions);
+        const cached = searchCache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+            return cached.results;
+        }
+        await enforceRateLimit();
+        // Try basic fetch first unless Puppeteer is forced or we are searching for images
+        if (!mergedOptions.forcePuppeteer && mergedOptions.category !== "images") {
+            try {
+                const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(query)}`;
+                await (0, common_1.fetchWithDetection)(searchUrl, mergedOptions);
+                // If no bot detection, use library
+                const results = await (0, google_sr_1.search)({
+                    query,
+                    parsers: [google_sr_1.OrganicResult],
+                    noPartialResults: true,
+                    requestConfig: { queryParams: { safe: "active" } },
+                });
+                const formattedResults = results.map((r) => ({
+                    title: r.title || "",
+                    url: r.link || "",
+                    snippet: r.description || "",
+                    source: "google",
+                }));
+                searchCache.set(cacheKey, {
+                    results: formattedResults,
+                    timestamp: Date.now(),
+                    source: "google",
+                });
+                return formattedResults;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage === "Bot protection detected" && mergedOptions.antiBot?.enabled) {
+                    // Silent fallback
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        // Use Puppeteer as fallback
+        const results = await searchWithPuppeteer(query, mergedOptions);
+        searchCache.set(cacheKey, {
+            results,
+            timestamp: Date.now(),
+            source: "google",
+        });
+        return results;
+    }
+    catch (error) {
+        throw {
+            message: "google search failed :(",
+            code: "GOOGLE_SEARCH_ERROR",
+            originalError: error,
+        };
+    }
+}

package/dist/modules/scrapers/searxng.d.ts

@@ -0,0 +1,2 @@
+import { ScraperOptions, SearchResult } from "../../types";
+export declare function searchSearxNG(query: string, options?: ScraperOptions): Promise<SearchResult[]>;

package/dist/modules/scrapers/searxng.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchSearxNG = searchSearxNG;
+const common_1 = require("../common");
+// Default public SearxNG instances
+const DEFAULT_INSTANCES = [
+    "https://searx.be",
+    "https://searx.space",
+    "https://search.mdosch.de",
+    "https://searx.work",
+    "https://searx.fmac.xyz",
+    "https://northboot.xyz",
+];
+// Cache for search results
+const searchCache = new Map();
+const CACHE_TTL = 60 * 60 * 1000; // 1 hour
+async function searchSearxNG(query, options = {}) {
+    try {
+        const mergedOptions = {
+            limit: 10,
+            safeSearch: true,
+            timeout: 10000,
+            ...options,
+        };
+        const cacheKey = (0, common_1.getCacheKey)(query, mergedOptions);
+        const cached = searchCache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+            return cached.results;
+        }
+        // Use provided instance or pick a random default
+        const instance = mergedOptions.searxngInstance || DEFAULT_INSTANCES[Math.floor(Math.random() * DEFAULT_INSTANCES.length)];
+        // Construct URL with JSON format
+        const searchUrl = new URL(`${instance}/search`);
+        searchUrl.searchParams.append("q", query);
+        searchUrl.searchParams.append("format", "json");
+        searchUrl.searchParams.append("safesearch", mergedOptions.safeSearch ? "1" : "0");
+        if (mergedOptions.category === "images") {
+            searchUrl.searchParams.append("categories", "images");
+        }
+        try {
+            const { body } = await (0, common_1.fetchWithDetection)(searchUrl.toString(), mergedOptions);
+            const data = JSON.parse(body);
+            if (!data.results || !Array.isArray(data.results)) {
+                throw new Error("Invalid response format from SearxNG");
+            }
+            if (mergedOptions.category === "images") {
+                const results = data.results
+                    .slice(0, mergedOptions.limit)
+                    .filter((r) => r.img_src || r.thumbnail_src || r.url.match(/\.(jpeg|jpg|gif|png)$/i))
+                    .map((r) => ({
+                    title: r.title,
+                    url: r.url,
+                    snippet: r.content || r.title,
+                    imageUrl: r.img_src || r.url,
+                    thumbnailUrl: r.thumbnail_src || r.thumbnail || r.img_src || r.url,
+                    source: "searxng-images",
+                }));
+                searchCache.set(cacheKey, {
+                    results,
+                    timestamp: Date.now(),
+                    source: "searxng",
+                });
+                return results;
+            }
+            const results = data.results.slice(0, mergedOptions.limit).map((r) => ({
+                title: r.title,
+                url: r.url,
+                snippet: r.content || "",
+                source: "searxng",
+            }));
+            searchCache.set(cacheKey, {
+                results,
+                timestamp: Date.now(),
+                source: "searxng",
+            });
+            return results;
+        }
+        catch (error) {
+            // If specific error, rethrow
+            if (error instanceof Error && error.message.includes("Bot protection")) {
+                throw error;
+            }
+            throw new Error(`Failed to fetch from SearxNG instance ${instance}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    catch (error) {
+        throw {
+            message: "searxng search failed",
+            code: "SEARXNG_SEARCH_ERROR",
+            originalError: error,
+        };
+    }
+}

package/dist/modules/scrapers/thetvdb.d.ts

@@ -0,0 +1,3 @@
+import { MediaResult, MediaSearchOptions } from "../../types";
+export declare function searchTheTVDB(query: string, options?: MediaSearchOptions): Promise<MediaResult[]>;
+export declare function getTheTVDBDetails(url: string, options?: MediaSearchOptions): Promise<Partial<MediaResult>>;

package/dist/modules/scrapers/thetvdb.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchTheTVDB = searchTheTVDB;
+exports.getTheTVDBDetails = getTheTVDBDetails;
+const common_1 = require("../common");
+const jsdom_1 = require("jsdom");
+// Rate limiting
+const MIN_DELAY = 1500;
+let lastSearchTime = 0;
+async function enforceRateLimit() {
+    const now = Date.now();
+    const timeSinceLast = now - lastSearchTime;
+    if (timeSinceLast < MIN_DELAY) {
+        await new Promise((resolve) => setTimeout(resolve, MIN_DELAY - timeSinceLast));
+    }
+    lastSearchTime = Date.now();
+}
+async function searchTheTVDB(query, options = {}) {
+    try {
+        await enforceRateLimit();
+        const mergedOptions = { ...options };
+        const searchUrl = `https://thetvdb.com/search?query=${encodeURIComponent(query)}`;
+        // Try basic fetch first
+        try {
+            if (!mergedOptions.forcePuppeteer) {
+                return await scrapeTheTVDBWithFetch(searchUrl, mergedOptions);
+            }
+        }
+        catch (e) {
+            if (mergedOptions.forcePuppeteer)
+                throw e;
+        }
+        // Fallback to Puppeteer
+        return await scrapeTheTVDBWithPuppeteer(searchUrl, mergedOptions);
+    }
+    catch (error) {
+        throw {
+            message: "TheTVDB search failed",
+            code: "THETVDB_SEARCH_ERROR",
+            originalError: error,
+        };
+    }
+}
+async function scrapeTheTVDBWithFetch(url, options) {
+    const { body } = await (0, common_1.fetchWithDetection)(url, options);
+    const dom = new jsdom_1.JSDOM(body);
+    return parseTheTVDBResults(dom.window.document);
+}
+async function scrapeTheTVDBWithPuppeteer(url, options) {
+    const proxy = (0, common_1.parseProxyConfig)(options.proxy);
+    const browser = await (0, common_1.createStealthBrowser)(proxy || undefined);
+    try {
+        const page = await browser.newPage();
+        await page.setViewport({ width: 1920, height: 1080 });
+        await page.setExtraHTTPHeaders((0, common_1.createRealisticHeaders)());
+        await page.goto(url, { waitUntil: "networkidle2" });
+        // Wait for results list
+        try {
+            await page.waitForSelector(".list-group, .media-list", { timeout: 5000 });
+        }
+        catch (e) {
+            return [];
+        }
+        const html = await page.content();
+        const dom = new jsdom_1.JSDOM(html);
+        return parseTheTVDBResults(dom.window.document);
+    }
+    finally {
+        await browser.close();
+    }
+}
+function parseTheTVDBResults(doc) {
+    const results = [];
+    // TheTVDB search results usually look like list items
+    const items = doc.querySelectorAll(".list-group-item, li.media");
+    items.forEach((item) => {
+        if (results.length >= 10)
+            return;
+        const titleEl = item.querySelector("h4, .media-heading");
+        const linkEl = item.querySelector("a");
+        const imgEl = item.querySelector("img");
+        const overviewEl = item.querySelector("p, .overview");
+        const smallText = item.querySelector("small"); // Often contains date or network
+        if (titleEl && linkEl) {
+            const title = titleEl.textContent?.trim() || "";
+            let href = linkEl.getAttribute("href") || "";
+            if (href && !href.startsWith("http")) {
+                href = `https://thetvdb.com${href}`;
+            }
+            const description = overviewEl?.textContent?.trim();
+            let posterUrl = imgEl?.getAttribute("src") || undefined;
+            // Filter out placeholder images if possible
+            if (posterUrl?.includes("missing"))
+                posterUrl = undefined;
+            // Detect type
+            let mediaType = "tv"; // Default for TheTVDB
+            if (href.includes("/movies/")) {
+                mediaType = "movie";
+            }
+            // Often TheTVDB lists translations for "Series" or "Movie" in badges
+            const badges = item.querySelectorAll(".badge");
+            badges.forEach((badge) => {
+                const text = badge.textContent?.toLowerCase();
+                if (text === "movie")
+                    mediaType = "movie";
+                if (text === "series")
+                    mediaType = "tv";
+            });
+            results.push({
+                title,
+                url: href,
+                description,
+                releaseDate: smallText?.textContent?.trim(),
+                posterUrl,
+                source: "thetvdb",
+                mediaType,
+            });
+        }
+    });
+    return results;
+}
+async function getTheTVDBDetails(url, options = {}) {
+    try {
+        const { body } = await (0, common_1.fetchWithDetection)(url, options);
+        const dom = new jsdom_1.JSDOM(body);
+        const doc = dom.window.document;
+        // Extract genres
+        const genres = [];
+        // Look for genre links or definition lists
+        // Typically in a sidebar or info block
+        const genreLinks = doc.querySelectorAll("a[href*='/genres/']");
+        genreLinks.forEach((link) => {
+            if (link.textContent)
+                genres.push(link.textContent.trim());
+        });
+        // Rating
+        // TheTVDB structure for rating might be in a header or info block
+        // Assuming a generic approach or looking for specific class if known
+        // (This is best effort without live DOM inspection)
+        return {
+            genres: genres.length > 0 ? genres : undefined,
+        };
+    }
+    catch (e) {
+        return {};
+    }
+}

package/dist/modules/scrapers/tmdb.d.ts

@@ -0,0 +1,3 @@
+import { MediaResult, MediaSearchOptions } from "../../types";
+export declare function searchTMDB(query: string, options?: MediaSearchOptions): Promise<MediaResult[]>;
+export declare function getTMDBDetails(url: string, options?: MediaSearchOptions): Promise<Partial<MediaResult>>;

package/dist/modules/scrapers/tmdb.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchTMDB = searchTMDB;
+exports.getTMDBDetails = getTMDBDetails;
+const common_1 = require("../common");
+const jsdom_1 = require("jsdom");
+// Rate limiting
+const MIN_DELAY = 1000;
+let lastSearchTime = 0;
+async function enforceRateLimit() {
+    const now = Date.now();
+    const timeSinceLast = now - lastSearchTime;
+    if (timeSinceLast < MIN_DELAY) {
+        await new Promise((resolve) => setTimeout(resolve, MIN_DELAY - timeSinceLast));
+    }
+    lastSearchTime = Date.now();
+}
+async function searchTMDB(query, options = {}) {
+    try {
+        await enforceRateLimit();
+        const mergedOptions = { ...options };
+        // Determine search type
+        let searchUrl = `https://www.themoviedb.org/search?query=${encodeURIComponent(query)}`;
+        if (mergedOptions.type === "movie") {
+            searchUrl = `https://www.themoviedb.org/search/movie?query=${encodeURIComponent(query)}`;
+        }
+        else if (mergedOptions.type === "tv") {
+            searchUrl = `https://www.themoviedb.org/search/tv?query=${encodeURIComponent(query)}`;
+        }
+        // First try basic fetch
+        try {
+            if (!mergedOptions.forcePuppeteer) {
+                return await scrapeTMDBWithFetch(searchUrl, mergedOptions);
+            }
+        }
+        catch (e) {
+            // Fallback to puppeteer below
+            if (mergedOptions.forcePuppeteer)
+                throw e;
+        }
+        // Fallback to Puppeteer
+        return await scrapeTMDBWithPuppeteer(searchUrl, mergedOptions);
+    }
+    catch (error) {
+        throw {
+            message: "TMDB search failed",
+            code: "TMDB_SEARCH_ERROR",
+            originalError: error,
+        };
+    }
+}
+async function scrapeTMDBWithFetch(url, options) {
+    const { body } = await (0, common_1.fetchWithDetection)(url, options);
+    const dom = new jsdom_1.JSDOM(body);
+    const doc = dom.window.document;
+    return parseTMDBResults(doc);
+}
+async function scrapeTMDBWithPuppeteer(url, options) {
+    const proxy = (0, common_1.parseProxyConfig)(options.proxy);
+    const browser = await (0, common_1.createStealthBrowser)(proxy || undefined);
+    try {
+        const page = await browser.newPage();
+        await page.setViewport({ width: 1920, height: 1080 });
+        await page.setExtraHTTPHeaders((0, common_1.createRealisticHeaders)());
+        await page.goto(url, { waitUntil: "networkidle2" });
+        // Wait for results
+        try {
+            await page.waitForSelector(".card", { timeout: 5000 });
+        }
+        catch (e) {
+            // No results found or timeout
+            return [];
+        }
+        const html = await page.content();
+        const dom = new jsdom_1.JSDOM(html);
+        return parseTMDBResults(dom.window.document);
+    }
+    finally {
+        await browser.close();
+    }
+}
+function parseTMDBResults(doc) {
+    const results = [];
+    const cards = doc.querySelectorAll(".card");
+    cards.forEach((card) => {
+        if (results.length >= 10)
+            return;
+        const titleEl = card.querySelector("h2");
+        const linkEl = card.querySelector("a.result"); // Usually the image link or title link
+        const dateEl = card.querySelector(".date");
+        const overviewEl = card.querySelector(".overview");
+        const imgEl = card.querySelector("img");
+        if (titleEl && linkEl) {
+            const title = titleEl.textContent?.trim() || "";
+            const href = linkEl.href;
+            const url = href.startsWith("http") ? href : `https://www.themoviedb.org${href}`;
+            const releaseDate = dateEl?.textContent?.trim();
+            const description = overviewEl?.textContent?.trim();
+            let posterUrl = imgEl?.src || imgEl?.getAttribute("data-src") || undefined;
+            if (posterUrl && !posterUrl.startsWith("http")) {
+                posterUrl = `https://www.themoviedb.org${posterUrl}`;
+            }
+            // Determine type from URL if possible
+            let mediaType = "movie"; // Default
+            if (url.includes("/tv/")) {
+                mediaType = "tv";
+            }
+            // Basic info first
+            results.push({
+                title,
+                url,
+                description,
+                releaseDate,
+                posterUrl,
+                source: "tmdb",
+                mediaType,
+            });
+        }
+    });
+    return results;
+}
+// Separate function to get details including cast and providers
+// This would be called if the user asks for specific details on a result
+async function getTMDBDetails(url, options = {}) {
+    // This function visits the detail page to get cast, genres, rating, providers
+    try {
+        const { body } = await (0, common_1.fetchWithDetection)(url, options);
+        const dom = new jsdom_1.JSDOM(body);
+        const doc = dom.window.document;
+        // Rating
+        const ratingEl = doc.querySelector(".user_score_chart");
+        const rating = ratingEl?.getAttribute("data-percent") ? `${ratingEl.getAttribute("data-percent")}%` : undefined;
+        // Genres
+        const genres = [];
+        doc.querySelectorAll(".genres a").forEach((el) => {
+            if (el.textContent)
+                genres.push(el.textContent.trim());
+        });
+        // Cast
+        const cast = [];
+        doc.querySelectorAll(".people.scroller li.card p a").forEach((el) => {
+            if (el.textContent)
+                cast.push(el.textContent.trim());
+        });
+        // Watch Providers (This is tricky as it's often loaded dynamically or in a separate section)
+        // TMDB often lists them in a section called "Where to Watch" or similar,
+        // but the actual data might be fetched via API or hidden.
+        // For basic scraping, we check for provider logos/links if visible.
+        const watchProviders = [];
+        // Check for provider list containers (provider structure varies)
+        const providerSections = doc.querySelectorAll(".provider");
+        providerSections.forEach((section) => {
+            const img = section.querySelector("img");
+            if (img) {
+                const name = img.getAttribute("alt") || "";
+                if (name) {
+                    // Heuristic to guess type usually requires more context, defaulting to stream
+                    watchProviders.push({ name, type: "stream" });
+                }
+            }
+        });
+        return {
+            rating,
+            genres,
+            cast,
+            watchProviders: watchProviders.length > 0 ? watchProviders : undefined,
+        };
+    }
+    catch (e) {
+        return {};
+    }
+}

package/dist/modules/scrapers/yahoo-finance.d.ts

@@ -0,0 +1,2 @@
+import { FinanceResult } from "../../types";
+export declare function getStockQuote(symbol: string): Promise<FinanceResult>;

package/dist/modules/scrapers/yahoo-finance.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStockQuote = getStockQuote;
+const yahoo_finance2_1 = __importDefault(require("yahoo-finance2"));
+async function getStockQuote(symbol) {
+    try {
+        // Explicitly cast to Quote to avoid type inference issues
+        const quote = await yahoo_finance2_1.default.quote(symbol);
+        return {
+            symbol: quote.symbol,
+            shortName: quote.shortName,
+            longName: quote.longName,
+            regularMarketPrice: quote.regularMarketPrice,
+            regularMarketChange: quote.regularMarketChange,
+            regularMarketChangePercent: quote.regularMarketChangePercent,
+            regularMarketTime: quote.regularMarketTime,
+            currency: quote.currency,
+            exchange: quote.exchange,
+            marketState: quote.marketState,
+            source: "yahoo-finance",
+        };
+    }
+    catch (error) {
+        throw {
+            message: `Failed to fetch quote for symbol: ${symbol}`,
+            code: "FINANCE_QUOTE_ERROR",
+            originalError: error,
+        };
+    }
+}

package/dist/modules/search.d.ts

@@ -0,0 +1,5 @@
+import { ScraperOptions, SearchResult } from "../types";
+export { searchGoogle } from "./scrapers/google";
+export { searchDuckDuckGo } from "./scrapers/duckduckgo";
+export { searchSearxNG } from "./scrapers/searxng";
+export declare function search(query: string, options?: ScraperOptions): Promise<SearchResult[]>;