llm-search-tools 1.1.0

package/dist/modules/media.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchMedia = searchMedia;
+exports.getMediaDetails = getMediaDetails;
+const tmdb_1 = require("./scrapers/tmdb");
+const thetvdb_1 = require("./scrapers/thetvdb");
+const anidb_1 = require("./scrapers/anidb");
+/**
+ * Unified Media Search
+ * Coordinates between TMDB, TheTVDB, and AniDB with fallback logic.
+ */
+async function searchMedia(query, options = {}) {
+    const { type } = options;
+    let results = [];
+    const errors = [];
+    // Strategy Pattern based on media type
+    // 1. ANIME Specific Strategy
+    if (type === "anime") {
+        try {
+            // Try AniDB first for Anime
+            results = await (0, anidb_1.searchAniDB)(query, options);
+            if (results.length > 0)
+                return results;
+        }
+        catch (e) {
+            errors.push(e);
+        }
+        // Fallback to TMDB with anime/tv type
+        try {
+            results = await (0, tmdb_1.searchTMDB)(query, { ...options, type: "tv" }); // Anime is often under TV in TMDB
+            // Filter for animation genre if possible, but for now just return results
+            if (results.length > 0)
+                return results;
+        }
+        catch (e) {
+            errors.push(e);
+        }
+    }
+    // 2. TV SHOW Strategy
+    else if (type === "tv") {
+        try {
+            // TMDB is generally faster and better structured for general TV
+            results = await (0, tmdb_1.searchTMDB)(query, options);
+            if (results.length > 0)
+                return results;
+        }
+        catch (e) {
+            errors.push(e);
+        }
+        try {
+            // Fallback to TheTVDB
+            results = await (0, thetvdb_1.searchTheTVDB)(query, options);
+            if (results.length > 0)
+                return results;
+        }
+        catch (e) {
+            errors.push(e);
+        }
+    }
+    // 3. MOVIE or GENERAL Strategy
+    else {
+        try {
+            // TMDB is the best all-rounder
+            results = await (0, tmdb_1.searchTMDB)(query, options);
+            if (results.length > 0)
+                return results;
+        }
+        catch (e) {
+            errors.push(e);
+        }
+        // If generic search and TMDB failed or found nothing, maybe try TheTVDB?
+        // Only if type wasn't specified as "movie" (TheTVDB is mostly TV)
+        if (type !== "movie" && results.length === 0) {
+            try {
+                const tvdbResults = await (0, thetvdb_1.searchTheTVDB)(query, options);
+                if (tvdbResults.length > 0)
+                    return tvdbResults;
+            }
+            catch (e) {
+                errors.push(e);
+            }
+        }
+    }
+    if (results.length === 0 && errors.length > 0) {
+        throw {
+            message: "Media search failed on all providers",
+            code: "MEDIA_SEARCH_FAILED",
+            originalError: errors[0], // Return the first error for context
+        };
+    }
+    return results;
+}
+/**
+ * Get detailed information for a media result.
+ * Automatically determines the source based on the URL or accepts an explicit source.
+ */
+async function getMediaDetails(url, source, options = {}) {
+    // Infer source from URL if not provided
+    if (!source) {
+        if (url.includes("themoviedb.org"))
+            source = "tmdb";
+        else if (url.includes("thetvdb.com"))
+            source = "thetvdb";
+        else if (url.includes("anidb.net"))
+            source = "anidb";
+        else {
+            throw {
+                message: "Could not determine media source from URL",
+                code: "UNKNOWN_MEDIA_SOURCE",
+            };
+        }
+    }
+    try {
+        switch (source) {
+            case "tmdb":
+                return await (0, tmdb_1.getTMDBDetails)(url, options);
+            case "thetvdb":
+                return await (0, thetvdb_1.getTheTVDBDetails)(url, options);
+            case "anidb":
+                return await (0, anidb_1.getAniDBDetails)(url, options);
+            default:
+                return {};
+        }
+    }
+    catch (error) {
+        throw {
+            message: `Failed to get details from ${source}`,
+            code: "MEDIA_DETAILS_FAILED",
+            originalError: error,
+        };
+    }
+}

package/dist/modules/media.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/media.test.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const media_1 = require("./media");
+const aniDB = __importStar(require("./scrapers/anidb"));
+const tmdb = __importStar(require("./scrapers/tmdb"));
+const theTVDB = __importStar(require("./scrapers/thetvdb"));
+// Mock the scrapers
+vitest_1.vi.mock("./scrapers/anidb");
+vitest_1.vi.mock("./scrapers/tmdb");
+vitest_1.vi.mock("./scrapers/thetvdb");
+(0, vitest_1.describe)("Media Search Coordinator", () => {
+    const mockAnimeResult = {
+        title: "Test Anime",
+        url: "https://anidb.net/anime/1",
+        source: "anidb",
+        mediaType: "anime",
+    };
+    const mockTVResult = {
+        title: "Test TV Show",
+        url: "https://themoviedb.org/tv/1",
+        source: "tmdb",
+        mediaType: "tv",
+    };
+    const mockMovieResult = {
+        title: "Test Movie",
+        url: "https://themoviedb.org/movie/1",
+        source: "tmdb",
+        mediaType: "movie",
+    };
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.describe)("searchMedia", () => {
+        (0, vitest_1.describe)("Anime Strategy", () => {
+            (0, vitest_1.it)("should try AniDB first for anime", async () => {
+                vitest_1.vi.mocked(aniDB.searchAniDB).mockResolvedValue([mockAnimeResult]);
+                const results = await (0, media_1.searchMedia)("Naruto", { type: "anime" });
+                (0, vitest_1.expect)(aniDB.searchAniDB).toHaveBeenCalledWith("Naruto", vitest_1.expect.objectContaining({ type: "anime" }));
+                (0, vitest_1.expect)(tmdb.searchTMDB).not.toHaveBeenCalled();
+                (0, vitest_1.expect)(results).toEqual([mockAnimeResult]);
+            });
+            (0, vitest_1.it)("should fall back to TMDB if AniDB fails", async () => {
+                vitest_1.vi.mocked(aniDB.searchAniDB).mockRejectedValue(new Error("AniDB down"));
+                vitest_1.vi.mocked(tmdb.searchTMDB).mockResolvedValue([mockTVResult]);
+                const results = await (0, media_1.searchMedia)("Naruto", { type: "anime" });
+                (0, vitest_1.expect)(aniDB.searchAniDB).toHaveBeenCalled();
+                (0, vitest_1.expect)(tmdb.searchTMDB).toHaveBeenCalledWith("Naruto", vitest_1.expect.objectContaining({ type: "tv" }));
+                (0, vitest_1.expect)(results).toEqual([mockTVResult]);
+            });
+            (0, vitest_1.it)("should fall back to TMDB if AniDB returns empty", async () => {
+                vitest_1.vi.mocked(aniDB.searchAniDB).mockResolvedValue([]);
+                vitest_1.vi.mocked(tmdb.searchTMDB).mockResolvedValue([mockTVResult]);
+                const results = await (0, media_1.searchMedia)("Naruto", { type: "anime" });
+                (0, vitest_1.expect)(aniDB.searchAniDB).toHaveBeenCalled();
+                (0, vitest_1.expect)(tmdb.searchTMDB).toHaveBeenCalled();
+                (0, vitest_1.expect)(results).toEqual([mockTVResult]);
+            });
+        });
+        (0, vitest_1.describe)("TV Strategy", () => {
+            (0, vitest_1.it)("should try TMDB first for TV", async () => {
+                vitest_1.vi.mocked(tmdb.searchTMDB).mockResolvedValue([mockTVResult]);
+                const results = await (0, media_1.searchMedia)("Breaking Bad", { type: "tv" });
+                (0, vitest_1.expect)(tmdb.searchTMDB).toHaveBeenCalledWith("Breaking Bad", vitest_1.expect.objectContaining({ type: "tv" }));
+                (0, vitest_1.expect)(theTVDB.searchTheTVDB).not.toHaveBeenCalled();
+                (0, vitest_1.expect)(results).toEqual([mockTVResult]);
+            });
+            (0, vitest_1.it)("should fall back to TheTVDB if TMDB fails", async () => {
+                vitest_1.vi.mocked(tmdb.searchTMDB).mockRejectedValue(new Error("TMDB down"));
+                vitest_1.vi.mocked(theTVDB.searchTheTVDB).mockResolvedValue([mockTVResult]);
+                const results = await (0, media_1.searchMedia)("Breaking Bad", { type: "tv" });
+                (0, vitest_1.expect)(tmdb.searchTMDB).toHaveBeenCalled();
+                (0, vitest_1.expect)(theTVDB.searchTheTVDB).toHaveBeenCalledWith("Breaking Bad", vitest_1.expect.objectContaining({ type: "tv" }));
+                (0, vitest_1.expect)(results).toEqual([mockTVResult]);
+            });
+        });
+        (0, vitest_1.describe)("General/Movie Strategy", () => {
+            (0, vitest_1.it)("should default to TMDB for unspecified type", async () => {
+                vitest_1.vi.mocked(tmdb.searchTMDB).mockResolvedValue([mockMovieResult]);
+                const results = await (0, media_1.searchMedia)("Inception", {});
+                (0, vitest_1.expect)(tmdb.searchTMDB).toHaveBeenCalledWith("Inception", {});
+                (0, vitest_1.expect)(results).toEqual([mockMovieResult]);
+            });
+            (0, vitest_1.it)("should try TheTVDB if general TMDB search fails and type is not movie", async () => {
+                // TMDB fails/returns empty
+                vitest_1.vi.mocked(tmdb.searchTMDB).mockResolvedValue([]);
+                vitest_1.vi.mocked(theTVDB.searchTheTVDB).mockResolvedValue([mockTVResult]);
+                // No type specified, so it could be a TV show
+                const results = await (0, media_1.searchMedia)("Unknown Show", {});
+                (0, vitest_1.expect)(tmdb.searchTMDB).toHaveBeenCalled();
+                (0, vitest_1.expect)(theTVDB.searchTheTVDB).toHaveBeenCalled();
+                (0, vitest_1.expect)(results).toEqual([mockTVResult]);
+            });
+            (0, vitest_1.it)("should NOT try TheTVDB if type is explicitly movie", async () => {
+                vitest_1.vi.mocked(tmdb.searchTMDB).mockResolvedValue([]);
+                try {
+                    await (0, media_1.searchMedia)("Unknown Movie", { type: "movie" });
+                }
+                catch {
+                    // Expected to throw
+                }
+                (0, vitest_1.expect)(tmdb.searchTMDB).toHaveBeenCalled();
+                (0, vitest_1.expect)(theTVDB.searchTheTVDB).not.toHaveBeenCalled();
+            });
+        });
+        (0, vitest_1.describe)("Error Handling", () => {
+            (0, vitest_1.it)("should throw SearchError if all providers fail", async () => {
+                vitest_1.vi.mocked(aniDB.searchAniDB).mockRejectedValue(new Error("Fail 1"));
+                vitest_1.vi.mocked(tmdb.searchTMDB).mockRejectedValue(new Error("Fail 2"));
+                await (0, vitest_1.expect)((0, media_1.searchMedia)("Nothing", { type: "anime" })).rejects.toMatchObject({
+                    code: "MEDIA_SEARCH_FAILED",
+                    message: "Media search failed on all providers",
+                });
+            });
+        });
+    });
+    (0, vitest_1.describe)("getMediaDetails", () => {
+        const mockDetails = { genres: ["Action"], cast: ["Actor A"] };
+        (0, vitest_1.it)("should call getTMDBDetails for TMDB URLs", async () => {
+            vitest_1.vi.mocked(tmdb.getTMDBDetails).mockResolvedValue(mockDetails);
+            const url = "https://www.themoviedb.org/movie/123";
+            const result = await (0, media_1.getMediaDetails)(url);
+            (0, vitest_1.expect)(tmdb.getTMDBDetails).toHaveBeenCalledWith(url, vitest_1.expect.anything());
+            (0, vitest_1.expect)(result).toEqual(mockDetails);
+        });
+        (0, vitest_1.it)("should call getTheTVDBDetails for TheTVDB URLs", async () => {
+            vitest_1.vi.mocked(theTVDB.getTheTVDBDetails).mockResolvedValue(mockDetails);
+            const url = "https://thetvdb.com/series/breaking-bad";
+            const result = await (0, media_1.getMediaDetails)(url);
+            (0, vitest_1.expect)(theTVDB.getTheTVDBDetails).toHaveBeenCalledWith(url, vitest_1.expect.anything());
+            (0, vitest_1.expect)(result).toEqual(mockDetails);
+        });
+        (0, vitest_1.it)("should call getAniDBDetails for AniDB URLs", async () => {
+            vitest_1.vi.mocked(aniDB.getAniDBDetails).mockResolvedValue(mockDetails);
+            const url = "https://anidb.net/anime/123";
+            const result = await (0, media_1.getMediaDetails)(url);
+            (0, vitest_1.expect)(aniDB.getAniDBDetails).toHaveBeenCalledWith(url, vitest_1.expect.anything());
+            (0, vitest_1.expect)(result).toEqual(mockDetails);
+        });
+        (0, vitest_1.it)("should use explicit source if provided", async () => {
+            vitest_1.vi.mocked(tmdb.getTMDBDetails).mockResolvedValue(mockDetails);
+            const url = "https://some-mirror.com/movie/123";
+            await (0, media_1.getMediaDetails)(url, "tmdb");
+            (0, vitest_1.expect)(tmdb.getTMDBDetails).toHaveBeenCalledWith(url, vitest_1.expect.anything());
+        });
+        (0, vitest_1.it)("should throw error for unknown sources", async () => {
+            const url = "https://unknown.com/movie/123";
+            await (0, vitest_1.expect)((0, media_1.getMediaDetails)(url)).rejects.toMatchObject({
+                code: "UNKNOWN_MEDIA_SOURCE",
+            });
+        });
+    });
+});

package/dist/modules/news.d.ts

@@ -0,0 +1,3 @@
+import { ScraperOptions, NewsResult } from "../types";
+export { searchGoogleNews } from "./scrapers/google-news";
+export declare function searchNews(query: string, options?: ScraperOptions): Promise<NewsResult[]>;

package/dist/modules/news.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchGoogleNews = void 0;
+exports.searchNews = searchNews;
+const google_news_1 = require("./scrapers/google-news");
+const duckduckgo_1 = require("./scrapers/duckduckgo");
+// Re-export specific news search functions
+var google_news_2 = require("./scrapers/google-news");
+Object.defineProperty(exports, "searchGoogleNews", { enumerable: true, get: function () { return google_news_2.searchGoogleNews; } });
+// Unified news search that tries engines in sequence: Google News -> DuckDuckGo News
+async function searchNews(query, options = {}) {
+    const errors = [];
+    // 1. Try Google News first (specialized news scraper)
+    try {
+        return await (0, google_news_1.searchGoogleNews)(query, options);
+    }
+    catch (err) {
+        errors.push(err);
+    }
+    // 2. Try DuckDuckGo with news category
+    try {
+        const ddgOptions = { ...options, category: "news" };
+        const results = await (0, duckduckgo_1.searchDuckDuckGo)(query, ddgOptions);
+        // Convert generic SearchResult to NewsResult
+        return results.map((result) => ({
+            ...result,
+            source: "duckduckgo-news",
+        }));
+    }
+    catch (err) {
+        errors.push(err);
+    }
+    // If all failed, throw error with details
+    throw {
+        message: "All news search engines failed",
+        code: "ALL_NEWS_ENGINES_FAILED",
+        errors,
+    };
+}

package/dist/modules/news.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/news.test.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const news_1 = require("./news");
+const google_news_1 = require("./scrapers/google-news");
+const duckduckgo_1 = require("./scrapers/duckduckgo");
+const google_news_scraper_1 = __importDefault(require("google-news-scraper"));
+// Mock dependencies
+vitest_1.vi.mock("google-news-scraper");
+vitest_1.vi.mock("./scrapers/duckduckgo");
+vitest_1.vi.mock("./scrapers/google-news", async () => {
+    const actual = await vitest_1.vi.importActual("./scrapers/google-news");
+    return {
+        ...actual,
+        // We want to test the real implementation of searchGoogleNews sometimes,
+        // but for searchNews orchestrator tests we might want to mock it.
+        // However, since searchGoogleNews is simple, we can mock the underlying library instead.
+    };
+});
+(0, vitest_1.describe)("News Module", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.describe)("searchGoogleNews", () => {
+        (0, vitest_1.it)("should return formatted news results", async () => {
+            const mockArticles = [
+                {
+                    title: "Test News",
+                    link: "https://news.com/article",
+                    image: "https://news.com/image.jpg",
+                    source: "News Source",
+                    time: "2 hours ago",
+                    subtitle: "Snippet text",
+                },
+            ];
+            google_news_scraper_1.default.mockResolvedValue(mockArticles);
+            const results = await (0, google_news_1.searchGoogleNews)("test google news");
+            (0, vitest_1.expect)(results).toHaveLength(1);
+            (0, vitest_1.expect)(results[0]).toEqual({
+                title: "Test News",
+                url: "https://news.com/article",
+                imageUrl: "https://news.com/image.jpg",
+                source: "google-news",
+                sourceName: "News Source",
+                publishedAt: "2 hours ago",
+                snippet: "Snippet text",
+            });
+        });
+        (0, vitest_1.it)("should handle errors", async () => {
+            google_news_scraper_1.default.mockRejectedValue(new Error("Scrape failed"));
+            await (0, vitest_1.expect)((0, google_news_1.searchGoogleNews)("test error")).rejects.toMatchObject({
+                code: "GOOGLE_NEWS_SEARCH_ERROR",
+            });
+        });
+    });
+    (0, vitest_1.describe)("searchNews (Orchestrator)", () => {
+        (0, vitest_1.it)("should try Google News first", async () => {
+            const mockArticles = [{ title: "GNews", link: "url", source: "G" }];
+            google_news_scraper_1.default.mockResolvedValue(mockArticles);
+            const results = await (0, news_1.searchNews)("test orchestrator");
+            (0, vitest_1.expect)(results[0].source).toBe("google-news");
+            (0, vitest_1.expect)(google_news_scraper_1.default).toHaveBeenCalled();
+            (0, vitest_1.expect)(duckduckgo_1.searchDuckDuckGo).not.toHaveBeenCalled();
+        });
+        (0, vitest_1.it)("should fallback to DuckDuckGo if Google News fails", async () => {
+            // Mock Google News failure
+            google_news_scraper_1.default.mockRejectedValue(new Error("Fail"));
+            // Mock DDG success
+            duckduckgo_1.searchDuckDuckGo.mockResolvedValue([
+                { title: "DDG News", url: "url", snippet: "desc", source: "duckduckgo" },
+            ]);
+            const results = await (0, news_1.searchNews)("test fallback");
+            (0, vitest_1.expect)(results[0].source).toBe("duckduckgo-news");
+            (0, vitest_1.expect)(google_news_scraper_1.default).toHaveBeenCalled();
+            (0, vitest_1.expect)(duckduckgo_1.searchDuckDuckGo).toHaveBeenCalledWith("test fallback", vitest_1.expect.objectContaining({ category: "news" }));
+        });
+        (0, vitest_1.it)("should throw if all providers fail", async () => {
+            google_news_scraper_1.default.mockRejectedValue(new Error("Fail 1"));
+            duckduckgo_1.searchDuckDuckGo.mockRejectedValue(new Error("Fail 2"));
+            await (0, vitest_1.expect)((0, news_1.searchNews)("test all fail")).rejects.toMatchObject({
+                code: "ALL_NEWS_ENGINES_FAILED",
+            });
+        });
+    });
+});

package/dist/modules/parser.d.ts

@@ -0,0 +1,19 @@
+export type FileType = "pdf" | "docx" | "csv" | "image" | "text" | "xml" | "json" | "unknown";
+export interface ParseOptions {
+    language?: string;
+    csv?: {
+        delimiter?: string;
+        columns?: boolean;
+    };
+    xml?: {
+        ignoreAttributes?: boolean;
+        parseAttributeValue?: boolean;
+    };
+}
+export interface ParseResult {
+    type: FileType;
+    text: string;
+    metadata?: Record<string, unknown>;
+    data?: unknown;
+}
+export declare function parse(pathOrBuffer: string | Buffer, options?: ParseOptions, filename?: string): Promise<ParseResult>;