howlongtobeat-core 0.1.0

package/script/src/http/client.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * HTTP client for HowLongToBeat API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSearchRequest = buildSearchRequest;
+exports.executeSearch = executeSearch;
+exports.fetchGamePage = fetchGamePage;
+exports.extractGameTitle = extractGameTitle;
+exports.getBaseUrl = getBaseUrl;
+exports.clearCache = clearCache;
+const HLTB_BASE_URL = "https://howlongtobeat.com";
+const HLTB_SEARCH_URL = `${HLTB_BASE_URL}/api/search`;
+const HLTB_GAME_URL = `${HLTB_BASE_URL}/game`;
+/**
+ * List of User-Agent strings for rotation
+ */
+const USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.0.0",
+];
+/**
+ * Get a random User-Agent string
+ */
+function getRandomUserAgent() {
+    return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
+}
+/**
+ * Cached auth token and its expiry
+ */
+let cachedToken = null;
+let tokenExpiry = 0;
+const TOKEN_TTL_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Cached search API URL
+ */
+let cachedSearchUrl = null;
+/**
+ * Fetch auth token from HLTB
+ */
+async function fetchAuthToken() {
+    // Check cache first
+    if (cachedToken && Date.now() < tokenExpiry) {
+        return cachedToken;
+    }
+    try {
+        const timestamp = Date.now();
+        const response = await fetch(`${HLTB_BASE_URL}/api/search/init?t=${timestamp}`, {
+            headers: {
+                "User-Agent": getRandomUserAgent(),
+                "Referer": HLTB_BASE_URL,
+            },
+        });
+        if (!response.ok) {
+            // TODO: implement proper error handling
+            console.error(`Failed to fetch auth token: ${response.status}`);
+            return null;
+        }
+        const data = (await response.json());
+        cachedToken = data.token || null;
+        tokenExpiry = Date.now() + TOKEN_TTL_MS;
+        return cachedToken;
+    }
+    catch (error) {
+        // TODO: implement proper error handling
+        console.error("Error fetching auth token:", error);
+        return null;
+    }
+}
+/**
+ * Discover the dynamic search API URL from HLTB's JavaScript bundles
+ */
+async function discoverSearchUrl() {
+    if (cachedSearchUrl) {
+        return cachedSearchUrl;
+    }
+    try {
+        // Fetch the main page
+        const response = await fetch(HLTB_BASE_URL, {
+            headers: {
+                "User-Agent": getRandomUserAgent(),
+            },
+        });
+        if (!response.ok) {
+            // TODO: implement proper error handling
+            console.error(`Failed to fetch main page: ${response.status}`);
+            return HLTB_SEARCH_URL;
+        }
+        const html = await response.text();
+        // Find _app-*.js bundle URLs
+        const scriptPattern = /_app-[a-zA-Z0-9]+\.js/g;
+        const scripts = html.match(scriptPattern);
+        if (!scripts || scripts.length === 0) {
+            return HLTB_SEARCH_URL;
+        }
+        // Try to find the search endpoint in the scripts
+        for (const script of scripts) {
+            try {
+                const scriptUrl = `${HLTB_BASE_URL}/_next/static/chunks/pages/${script}`;
+                const scriptResponse = await fetch(scriptUrl, {
+                    headers: {
+                        "User-Agent": getRandomUserAgent(),
+                    },
+                });
+                if (!scriptResponse.ok)
+                    continue;
+                const scriptContent = await scriptResponse.text();
+                // Look for the search API path pattern
+                // Common patterns: "/api/search/", "api/search", etc.
+                const searchPathPattern = /["']([^"']*api\/search[^"']*)["']/g;
+                const matches = [...scriptContent.matchAll(searchPathPattern)];
+                for (const match of matches) {
+                    const path = match[1];
+                    if (path && !path.includes("init") && path.startsWith("/")) {
+                        cachedSearchUrl = `${HLTB_BASE_URL}${path}`;
+                        return cachedSearchUrl;
+                    }
+                }
+            }
+            catch {
+                // TODO: implement proper error handling
+                continue;
+            }
+        }
+    }
+    catch (error) {
+        // TODO: implement proper error handling
+        console.error("Error discovering search URL:", error);
+    }
+    // Fall back to known URL
+    cachedSearchUrl = HLTB_SEARCH_URL;
+    return cachedSearchUrl;
+}
+/**
+ * Build search request body
+ */
+function buildSearchRequest(searchTerms, modifier = "", page = 1, size = 20) {
+    return {
+        searchType: "games",
+        searchTerms,
+        searchPage: page,
+        size,
+        searchOptions: {
+            games: {
+                userId: 0,
+                platform: "",
+                sortCategory: "popular",
+                rangeCategory: "main",
+                rangeTime: { min: 0, max: 0 },
+                gameplay: {
+                    perspective: "",
+                    flow: "",
+                    genre: "",
+                    difficulty: "",
+                },
+                rangeYear: { max: "", min: "" },
+                modifier,
+            },
+            users: { sortCategory: "postcount" },
+            lists: { sortCategory: "follows" },
+            filter: "",
+            sort: 0,
+            randomizer: 0,
+        },
+        useCache: true,
+    };
+}
+/**
+ * Execute a search request to HLTB API
+ */
+async function executeSearch(gameName, modifier = "") {
+    const token = await fetchAuthToken();
+    if (!token) {
+        // TODO: implement proper error handling
+        return null;
+    }
+    const searchUrl = await discoverSearchUrl();
+    const searchTerms = gameName.split(" ").filter((term) => term.length > 0);
+    const requestBody = buildSearchRequest(searchTerms, modifier);
+    try {
+        const response = await fetch(searchUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "User-Agent": getRandomUserAgent(),
+                "Referer": HLTB_BASE_URL,
+                "x-auth-token": token,
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            // TODO: implement proper error handling
+            console.error(`Search request failed: ${response.status}`);
+            return null;
+        }
+        return await response.json();
+    }
+    catch (error) {
+        // TODO: implement proper error handling
+        console.error("Error executing search:", error);
+        return null;
+    }
+}
+/**
+ * Fetch game page HTML to extract game title
+ */
+async function fetchGamePage(gameId) {
+    try {
+        const response = await fetch(`${HLTB_GAME_URL}/${gameId}`, {
+            headers: {
+                "User-Agent": getRandomUserAgent(),
+                "Referer": HLTB_BASE_URL,
+            },
+        });
+        if (!response.ok) {
+            // TODO: implement proper error handling
+            return null;
+        }
+        return await response.text();
+    }
+    catch (error) {
+        // TODO: implement proper error handling
+        console.error("Error fetching game page:", error);
+        return null;
+    }
+}
+/**
+ * Extract game title from HLTB game page HTML
+ */
+function extractGameTitle(html) {
+    // Title format: "How long is {GAME_NAME}? | HowLongToBeat"
+    // Note: title tag may have attributes like data-next-head=""
+    const titlePattern = /<title[^>]*>How long is ([^?]+)\?[^<]*<\/title>/i;
+    const match = html.match(titlePattern);
+    if (match && match[1]) {
+        return match[1].trim();
+    }
+    // TODO: implement proper error handling
+    return null;
+}
+/**
+ * Get base URL for constructing image and web links
+ */
+function getBaseUrl() {
+    return HLTB_BASE_URL;
+}
+/**
+ * Clear cached token and search URL (useful for testing)
+ */
+function clearCache() {
+    cachedToken = null;
+    tokenExpiry = 0;
+    cachedSearchUrl = null;
+}

package/script/src/parser/json.d.ts

@@ -0,0 +1,17 @@
+/**
+ * JSON response parser for HowLongToBeat API
+ */
+import type { HLTBRawGame, HowLongToBeatEntry } from "../types.js";
+/**
+ * Convert a raw HLTB game object to HowLongToBeatEntry
+ */
+export declare function parseGameEntry(raw: HLTBRawGame, similarity?: number, autoFilterTimes?: boolean): HowLongToBeatEntry;
+/**
+ * Parse an array of raw games into HowLongToBeatEntry array
+ */
+export declare function parseGameEntries(rawGames: HLTBRawGame[], searchQuery: string, autoFilterTimes: boolean, calculateSimilarity: (a: string, b: string) => number): HowLongToBeatEntry[];
+/**
+ * Filter entries by minimum similarity threshold
+ */
+export declare function filterBySimilarity(entries: HowLongToBeatEntry[], minimumSimilarity: number): HowLongToBeatEntry[];
+//# sourceMappingURL=json.d.ts.map

package/script/src/parser/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/src/parser/json.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AA2BnE;;GAEG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,WAAW,EAChB,UAAU,GAAE,MAAU,EACtB,eAAe,GAAE,OAAe,GAC/B,kBAAkB,CAyEpB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,WAAW,EAAE,EACvB,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,OAAO,EACxB,mBAAmB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,GACpD,kBAAkB,EAAE,CAgBtB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,kBAAkB,EAAE,EAC7B,iBAAiB,EAAE,MAAM,GACxB,kBAAkB,EAAE,CAItB"}

package/script/src/parser/json.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * JSON response parser for HowLongToBeat API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGameEntry = parseGameEntry;
+exports.parseGameEntries = parseGameEntries;
+exports.filterBySimilarity = filterBySimilarity;
+const client_js_1 = require("../http/client.js");
+const HLTB_IMAGE_URL = "https://howlongtobeat.com/games";
+/**
+ * Convert seconds to hours with one decimal place
+ */
+function secondsToHours(seconds) {
+    if (seconds <= 0) {
+        return null;
+    }
+    return Math.round((seconds / 3600) * 10) / 10;
+}
+/**
+ * Parse platforms string into array
+ */
+function parsePlatforms(platformString) {
+    if (!platformString || platformString.trim() === "") {
+        return null;
+    }
+    return platformString.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+}
+/**
+ * Convert a raw HLTB game object to HowLongToBeatEntry
+ */
+function parseGameEntry(raw, similarity = 0, autoFilterTimes = false) {
+    const baseUrl = (0, client_js_1.getBaseUrl)();
+    // Determine game type flags
+    const complexityLvlCombine = raw.comp_lvl_combine === 1;
+    const complexityLvlSp = raw.comp_lvl_sp === 1;
+    const complexityLvlCo = raw.comp_lvl_co === 1;
+    const complexityLvlMp = raw.comp_lvl_mp === 1;
+    // Parse times
+    let mainStory = secondsToHours(raw.comp_main);
+    let mainExtra = secondsToHours(raw.comp_plus);
+    let completionist = secondsToHours(raw.comp_100);
+    let allStyles = secondsToHours(raw.comp_all);
+    let coopTime = secondsToHours(raw.invested_co);
+    let mpTime = secondsToHours(raw.invested_mp);
+    // Auto-filter times based on game type
+    if (autoFilterTimes) {
+        // If no singleplayer, nullify SP times
+        if (!complexityLvlSp && !complexityLvlCombine) {
+            mainStory = null;
+            mainExtra = null;
+            completionist = null;
+            allStyles = null;
+        }
+        // If no co-op, nullify co-op time
+        if (!complexityLvlCo && !complexityLvlCombine) {
+            coopTime = null;
+        }
+        // If no multiplayer, nullify MP time
+        if (!complexityLvlMp && !complexityLvlCombine) {
+            mpTime = null;
+        }
+    }
+    // Build image URL
+    let gameImageUrl = null;
+    if (raw.game_image) {
+        gameImageUrl = `${HLTB_IMAGE_URL}/${raw.game_image}`;
+    }
+    return {
+        gameId: raw.game_id,
+        gameName: raw.game_name || null,
+        gameAlias: raw.game_alias || null,
+        gameType: raw.game_type || null,
+        gameImageUrl,
+        gameWebLink: `${baseUrl}/game/${raw.game_id}`,
+        reviewScore: raw.review_score > 0 ? raw.review_score : null,
+        profileDev: raw.profile_dev || null,
+        profilePlatforms: parsePlatforms(raw.profile_platform),
+        releaseWorld: raw.release_world > 0 ? raw.release_world : null,
+        mainStory,
+        mainExtra,
+        completionist,
+        allStyles,
+        coopTime,
+        mpTime,
+        complexityLvlCombine,
+        complexityLvlSp,
+        complexityLvlCo,
+        complexityLvlMp,
+        similarity,
+        jsonContent: raw,
+    };
+}
+/**
+ * Parse an array of raw games into HowLongToBeatEntry array
+ */
+function parseGameEntries(rawGames, searchQuery, autoFilterTimes, calculateSimilarity) {
+    const normalizedQuery = searchQuery.toLowerCase().trim();
+    return rawGames.map((raw) => {
+        // Calculate similarity against game name and alias
+        const nameSimilarity = raw.game_name
+            ? calculateSimilarity(normalizedQuery, raw.game_name.toLowerCase())
+            : 0;
+        const aliasSimilarity = raw.game_alias
+            ? calculateSimilarity(normalizedQuery, raw.game_alias.toLowerCase())
+            : 0;
+        const similarity = Math.max(nameSimilarity, aliasSimilarity);
+        return parseGameEntry(raw, similarity, autoFilterTimes);
+    });
+}
+/**
+ * Filter entries by minimum similarity threshold
+ */
+function filterBySimilarity(entries, minimumSimilarity) {
+    return entries
+        .filter((entry) => entry.similarity >= minimumSimilarity)
+        .sort((a, b) => b.similarity - a.similarity);
+}

package/script/src/types.d.ts

@@ -0,0 +1,179 @@
+/**
+ * HowLongToBeat TypeScript types
+ */
+/**
+ * Search modifiers for filtering game results
+ */
+export declare enum SearchModifiers {
+    /** No modifier - include all results */
+    NONE = "",
+    /** Only show DLC content */
+    ISOLATE_DLC = "only_dlc",
+    /** Only show mods */
+    ISOLATE_MODS = "only_mods",
+    /** Only show hacks */
+    ISOLATE_HACKS = "only_hacks",
+    /** Hide DLC from results */
+    HIDE_DLC = "hide_dlc"
+}
+/**
+ * Similarity algorithm to use for filtering results
+ */
+export type SimilarityAlgorithm = "gestalt" | "levenshtein";
+/**
+ * Options for HowLongToBeat constructor
+ */
+export interface HowLongToBeatOptions {
+    /** Minimum similarity threshold (0-1). Default: 0.4 */
+    minimumSimilarity?: number;
+    /** Auto-nullify irrelevant time fields based on game type. Default: false */
+    autoFilterTimes?: boolean;
+    /** Similarity algorithm to use. Default: "gestalt" */
+    similarityAlgorithm?: SimilarityAlgorithm;
+}
+/**
+ * Represents a game entry from HowLongToBeat
+ */
+export interface HowLongToBeatEntry {
+    /** Unique game ID on HLTB */
+    gameId: number;
+    /** Game name */
+    gameName: string | null;
+    /** Alternative name/alias */
+    gameAlias: string | null;
+    /** Type of content: "game" or "dlc" */
+    gameType: string | null;
+    /** URL to the game's cover image */
+    gameImageUrl: string | null;
+    /** Direct link to the game's HLTB page */
+    gameWebLink: string;
+    /** Review score (0-100) */
+    reviewScore: number | null;
+    /** Developer name */
+    profileDev: string | null;
+    /** Available platforms */
+    profilePlatforms: string[] | null;
+    /** Release year */
+    releaseWorld: number | null;
+    /** Main story completion time */
+    mainStory: number | null;
+    /** Main story + extras completion time */
+    mainExtra: number | null;
+    /** 100% completionist time */
+    completionist: number | null;
+    /** Average of all playstyles */
+    allStyles: number | null;
+    /** Co-op completion time */
+    coopTime: number | null;
+    /** Multiplayer time */
+    mpTime: number | null;
+    /** Combined single/multi game */
+    complexityLvlCombine: boolean;
+    /** Has singleplayer content */
+    complexityLvlSp: boolean;
+    /** Has co-op content */
+    complexityLvlCo: boolean;
+    /** Has multiplayer content */
+    complexityLvlMp: boolean;
+    /** Similarity score to search query (0-1) */
+    similarity: number;
+    /** Full raw JSON response from HLTB */
+    jsonContent: Record<string, unknown>;
+}
+/**
+ * Raw game data from HLTB API response
+ */
+export interface HLTBRawGame {
+    game_id: number;
+    game_name: string;
+    game_name_date: number;
+    game_alias: string;
+    game_type: string;
+    game_image: string;
+    comp_lvl_combine: number;
+    comp_lvl_sp: number;
+    comp_lvl_co: number;
+    comp_lvl_mp: number;
+    comp_lvl_spd: number;
+    comp_main: number;
+    comp_plus: number;
+    comp_100: number;
+    comp_all: number;
+    comp_main_count: number;
+    comp_plus_count: number;
+    comp_100_count: number;
+    comp_all_count: number;
+    invested_co: number;
+    invested_mp: number;
+    invested_co_count: number;
+    invested_mp_count: number;
+    count_comp: number;
+    count_speedrun: number;
+    count_backlog: number;
+    count_review: number;
+    review_score: number;
+    count_playing: number;
+    count_retired: number;
+    profile_dev: string;
+    profile_popular: number;
+    profile_steam: number;
+    profile_platform: string;
+    release_world: number;
+    [key: string]: unknown;
+}
+/**
+ * HLTB API search response structure
+ */
+export interface HLTBSearchResponse {
+    color: string;
+    title: string;
+    category: string;
+    count: number;
+    pageCurrent: number;
+    pageTotal: number;
+    pageSize: number;
+    data: HLTBRawGame[];
+}
+/**
+ * Search request body for HLTB API
+ */
+export interface HLTBSearchRequest {
+    searchType: string;
+    searchTerms: string[];
+    searchPage: number;
+    size: number;
+    searchOptions: {
+        games: {
+            userId: number;
+            platform: string;
+            sortCategory: string;
+            rangeCategory: string;
+            rangeTime: {
+                min: number;
+                max: number;
+            };
+            gameplay: {
+                perspective: string;
+                flow: string;
+                genre: string;
+                difficulty: string;
+            };
+            rangeYear: {
+                max: string;
+                min: string;
+            };
+            modifier: string;
+        };
+        users: {
+            sortCategory: string;
+        };
+        lists: {
+            sortCategory: string;
+        };
+        filter: string;
+        sort: number;
+        randomizer: number;
+    };
+    useCache: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/script/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/src/types.ts"],"names":[],"mappings":"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"}

package/script/src/types.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * HowLongToBeat TypeScript types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchModifiers = void 0;
+/**
+ * Search modifiers for filtering game results
+ */
+var SearchModifiers;
+(function (SearchModifiers) {
+    /** No modifier - include all results */
+    SearchModifiers["NONE"] = "";
+    /** Only show DLC content */
+    SearchModifiers["ISOLATE_DLC"] = "only_dlc";
+    /** Only show mods */
+    SearchModifiers["ISOLATE_MODS"] = "only_mods";
+    /** Only show hacks */
+    SearchModifiers["ISOLATE_HACKS"] = "only_hacks";
+    /** Hide DLC from results */
+    SearchModifiers["HIDE_DLC"] = "hide_dlc";
+})(SearchModifiers || (exports.SearchModifiers = SearchModifiers = {}));

package/script/src/utils/similarity.d.ts

@@ -0,0 +1,28 @@
+/**
+ * String similarity algorithms for HowLongToBeat
+ *
+ * Provides both Gestalt pattern matching (like Python's difflib.SequenceMatcher)
+ * and Levenshtein distance-based similarity.
+ */
+import type { SimilarityAlgorithm } from "../types.js";
+/**
+ * Calculate similarity using the specified algorithm
+ */
+export declare function calculateSimilarity(a: string, b: string, algorithm?: SimilarityAlgorithm): number;
+/**
+ * Gestalt Pattern Matching similarity (like Python's difflib.SequenceMatcher)
+ *
+ * This implements the Ratcliff/Obershelp algorithm which finds the longest
+ * common substring and recursively processes the remaining parts.
+ */
+export declare function gestaltSimilarity(a: string, b: string): number;
+/**
+ * Calculate similarity based on Levenshtein distance
+ * Returns a value between 0 and 1, where 1 means identical strings
+ */
+export declare function levenshteinSimilarity(a: string, b: string): number;
+/**
+ * Create a similarity calculator function with a specific algorithm
+ */
+export declare function createSimilarityCalculator(algorithm?: SimilarityAlgorithm): (a: string, b: string) => number;
+//# sourceMappingURL=similarity.d.ts.map

package/script/src/utils/similarity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"similarity.d.ts","sourceRoot":"","sources":["../../../src/src/utils/similarity.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,SAAS,GAAE,mBAA+B,GACzC,MAAM,CAKR;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAM9D;AAuGD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAOlE;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,GAAE,mBAA+B,GACzC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAElC"}