mtg-playerinfo 1.0.0

package/.github/workflows/pull-player-data.yml

@@ -0,0 +1,26 @@
+name: Pull Player Data
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  run-tool:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Run MTG Player Info Tool for sample player
+        run: node cli.js --unity-id 16215 --mtgelo-id 3irvwtmk --melee-user k0shiii --topdeck-handle k0shiii
+

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Björn Kimminich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,89 @@
+# MTG Player Info
+
+A simple NPM module and CLI tool to pull Magic: The Gathering player data from various sources (Unity League, MTG Elo Project, Melee, and Topdeck).
+
+## Installation
+
+```bash
+npm install
+```
+
+## CLI Usage
+
+```bash
+node cli.js --unity-id 16215 --mtgelo-id 3irvwtmk --melee-user k0shiii --topdeck-handle k0shiii
+```
+
+## Output Format
+
+The tool returns a JSON object representing the player and their combined metadata. Redundant information like Name, Photo, Country, Age, and Hometown is merged into a `general` section, while source-specific data is kept in the `sources` section.
+
+### Deduplication and Merging Logic
+- **Priority**: Merging follows a "first-come, first-served" approach based on the order of sources provided in the command line or processed by the manager. For instance, the first valid `photo` URL found will be used as the primary photo for the player profile.
+- **Deduplication**: If multiple IDs point to the exact same profile URL, the profile is only processed once to avoid redundant data in the `sources` section.
+- **General Metadata**: Fields like `Age`, `Country`, and `Hometown` are extracted from the first source that provides them and placed in the `general` section.
+
+Example output:
+```json
+{
+  "name": "Björn Kimminich",
+  "photo": "https://unityleague.gg/media/player_profile/1000023225.jpg",
+  "general": {
+    "Age": "45",
+    "Bio": "Smugly held back on an Untimely Malfunction against a Storm player going off, being totally sure that you can redirect the summed-up damage of their Grapeshots back to their face with its \"Change the target of target spell or ability with a single target\" mode.",
+    "Team": "Mull to Five",
+    "Country": "de",
+    "Hometown": "Hamburg",
+    "Win Rate": "42.09%"
+  },
+  "sources": {
+    "Unity League": {
+      "url": "https://unityleague.gg/player/16215/",
+      "data": {
+        "Local organizer": "Mulligan TCG Shop",
+        "Rank Germany": "58",
+        "Rank Europe": "578",
+        "Rank Points": "274",
+        "Record": "38-38-5",
+        "Win Rate": "49.0%"
+      }
+    },
+    "MTG Elo Project": {
+      "url": "https://mtgeloproject.net/profile/3irvwtmk",
+      "data": {
+        "player_id": "3irvwtmk",
+        "current_rating": "1466",
+        "record": "9-12-1",
+        "Win Rate": "40.91%"
+      }
+    },
+    "Melee": {
+      "url": "https://melee.gg/Profile/Index/k0shiii",
+      "data": {
+        "username": "k0shiii"
+      }
+    },
+    "Topdeck": {
+      "url": "https://topdeck.gg/profile/@k0shiii",
+      "data": {
+        "handle": "@k0shiii",
+        "Tournaments": "2",
+        "Record": "4-6-1",
+        "Win Rate": "36.36%",
+        "Conversion": "0%"
+      }
+    }
+  }
+}
+```
+
+## Supported Sources
+
+| Site            | Method   |
+|-----------------|----------|
+| Unity League    | Scraping |
+| MTG Elo Project | Scraping |
+| Melee           | Scraping |
+| Topdeck         | Scraping |
+
+Note: Some sites may have anti-bot protections that can lead to "Maximum number of redirects exceeded" or "403 Forbidden" errors depending on the execution environment.

package/cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+const { program } = require('commander');
+const PlayerInfoManager = require('./src/index');
+
+program
+  .name('mtg-playerinfo')
+  .description('CLI to pull MTG player data from various sources')
+  .version('1.0.0');
+
+program
+  .option('--unity-id <id>', 'Unity League Player ID')
+  .option('--mtgelo-id <id>', 'MTG Elo Project Player ID')
+  .option('--melee-user <username>', 'Melee Username')
+  .option('--topdeck-handle <handle>', 'Topdeck Handle')
+  .action(async (options) => {
+    if (!options.unityId && !options.mtgeloId && !options.meleeUser && !options.topdeckHandle) {
+      console.error('Error: Please provide at least one search option (unity-id, mtgelo-id, melee-user, or topdeck-handle).');
+      process.exit(1);
+    }
+
+    const manager = new PlayerInfoManager();
+    try {
+      const playerInfo = await manager.getPlayerInfo(options);
+      console.log(JSON.stringify(playerInfo, null, 2));
+    } catch (error) {
+      console.error('An error occurred:', error.message);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "mtg-playerinfo",
+  "version": "1.0.0",
+  "description": "A simple NPM module and CLI tool to pull Magic: The Gathering player data from various sources",
+  "main": "src/index.js",
+  "bin": {
+    "mtg-playerinfo": "./cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Björn Kimminich",
+  "license": "MIT",
+  "dependencies": {
+    "cheerio": "^1.2.0",
+    "commander": "^14.0.3"
+  }
+}

package/src/fetchers/melee.js

@@ -0,0 +1,35 @@
+const { request } = require('../utils/httpClient');
+const cheerio = require('cheerio');
+
+class MeleeFetcher {
+  async fetchById(username) {
+    const url = `https://melee.gg/Profile/Index/${username}`;
+    try {
+      const { data } = await request(url);
+      return this.parseHtml(data, url, username);
+    } catch (error) {
+      console.error(`Error fetching Melee profile ${username}:`, error.message);
+      return null;
+    }
+  }
+
+  parseHtml(html, url, username) {
+    const $ = cheerio.load(html);
+    const name = $('span[style*="font-size: xx-large"]').first().text().trim() || username;
+    const photo = $('img.m-auto').attr('src');
+    
+    const data = {
+      source: 'Melee',
+      url,
+      name,
+      photo: photo ? (photo.startsWith('http') ? photo : `https://melee.gg${photo}`) : null,
+      details: {
+        username
+      }
+    };
+
+    return data;
+  }
+}
+
+module.exports = MeleeFetcher;

package/src/fetchers/mtgElo.js

@@ -0,0 +1,83 @@
+const { request } = require('../utils/httpClient');
+
+class MtgEloFetcher {
+  async fetchById(id) {
+    const url = `https://mtgeloproject.net/profile/${id}`;
+    try {
+      const { data: html } = await request(url, {
+        maxRedirects: 10
+      });
+
+      const cheerio = require('cheerio');
+      const $ = cheerio.load(html);
+
+      let name = '';
+      let currentRating = '';
+      let record = '';
+
+      const astroIsland = $('astro-island[component-url*="Profile"]');
+      if (astroIsland.length > 0) {
+        try {
+          const props = JSON.parse(astroIsland.attr('props'));
+          const info = props.info[1];
+          name = `${info.first_name[1]} ${info.last_name[1]}`;
+          currentRating = Math.round(info.current_rating[1]).toString();
+          const r = info.record[1];
+          record = `${r[0][1]}-${r[1][1]}-${r[2][1]}`;
+        } catch (e) {
+          console.error('Error parsing MTG Elo props:', e.message);
+        }
+      }
+
+      if (!name) {
+        name = $('.text-\\[22pt\\]').text().trim();
+        if (name.includes(',')) {
+          const parts = name.split(',').map(s => s.trim());
+          name = `${parts[1]} ${parts[0]}`;
+        }
+      }
+
+      if (!currentRating) {
+        currentRating = $('.text-\\[18pt\\]:contains("Current rating")').find('.font-bold').text().trim();
+      }
+
+      if (!record) {
+        const recordText = $('.text-\\[18pt\\]:contains("Record")').text();
+        record = recordText.replace('Record:', '').trim();
+      }
+
+      if (!name) return null;
+
+      const details = {
+        player_id: id,
+        current_rating: currentRating,
+        record: record
+      };
+
+      if (record && record.includes('-')) {
+        const [w, l, d] = record.split('-').map(Number);
+        if (!isNaN(w) && !isNaN(l)) {
+          const wins = w;
+          const losses = l;
+          const draws = isNaN(d) ? 0 : d;
+          const total = wins + losses + draws;
+          if (total > 0) {
+            details['Win Rate'] = ((wins / total) * 100).toFixed(2) + '%';
+          }
+        }
+      }
+
+      return {
+        source: 'MTG Elo Project',
+        url: url,
+        name: name,
+        details: details
+      };
+    } catch (error) {
+      console.error(`Error fetching MTG Elo Project profile ${id}:`, error.message);
+      return null;
+    }
+  }
+}
+
+module.exports = MtgEloFetcher;

package/src/fetchers/topdeck.js

@@ -0,0 +1,108 @@
+const { request } = require('../utils/httpClient');
+const cheerio = require('cheerio');
+
+class TopdeckFetcher {
+  async fetchById(handle) {
+    const cleanHandle = handle.startsWith('@') ? handle : `@${handle}`;
+    const url = `https://topdeck.gg/profile/${cleanHandle}`;
+    try {
+      const { data } = await request(url);
+      const playerInfo = this.parseHtml(data, url, cleanHandle);
+
+      // Try to fetch stats via XHR if internal ID is found
+      const internalIdMatch = data.match(/https:\/\/topdeck\.gg\/profile\/([a-zA-Z0-9]+)\/stats/) || data.match(/const playerId = "([a-zA-Z0-9]+)";/);
+      const internalId = internalIdMatch ? internalIdMatch[1] : null;
+
+      if (internalId) {
+        try {
+          const statsUrl = `https://topdeck.gg/profile/${internalId}/stats`;
+          const statsResponse = await request(statsUrl);
+          const statsJson = statsResponse.data;
+          const stats = typeof statsJson === 'string' ? JSON.parse(statsJson) : statsJson;
+
+          if (stats) {
+            if (stats.yearlyStats) {
+              let totalTournaments = 0;
+              let wins = 0;
+              let losses = 0;
+              let draws = 0;
+
+              Object.values(stats.yearlyStats).forEach(yearData => {
+                if (yearData.overall) {
+                  totalTournaments += yearData.overall.totalTournaments || 0;
+                  wins += yearData.overall.wins || 0;
+                  losses += yearData.overall.losses || 0;
+                  draws += yearData.overall.draws || 0;
+                }
+              });
+
+              if (totalTournaments > 0) {
+                playerInfo.details['Tournaments'] = totalTournaments.toString();
+                playerInfo.details['Record'] = `${wins}-${losses}-${draws}`;
+                playerInfo.details['Win Rate'] = ((wins / (wins + losses + draws)) * 100).toFixed(2) + '%';
+              }
+            } else {
+              playerInfo.details['Tournaments'] = stats.totalTournaments || playerInfo.details['Tournaments'] || '0';
+              playerInfo.details['Record'] = stats.overallRecord || playerInfo.details['Record'] || '0-0-0';
+              playerInfo.details['Win Rate'] = stats.overallWinRate || playerInfo.details['Win Rate'] || '0.00%';
+              playerInfo.details['Conversion'] = stats.conversionRate || playerInfo.details['Conversion'] || '0.00%';
+            }
+          }
+        } catch (statsError) {
+          console.error(`Error fetching Topdeck stats for ${handle}:`, statsError.message);
+        }
+      }
+
+      return playerInfo;
+    } catch (error) {
+      console.error(`Error fetching Topdeck profile ${handle}:`, error.message);
+      return null;
+    }
+  }
+
+  parseHtml(html, url, handle) {
+    const $ = cheerio.load(html);
+    const name = $('h2.text-white.fw-bold.mb-1').first().text().trim() || $('h1').first().text().trim() || handle;
+    const photo = $('img.rounded-circle.shadow-lg').first().attr('src') || $('img[src*="avatar"], img[src*="profile"]').first().attr('src');
+
+    const data = {
+      source: 'Topdeck',
+      url,
+      name,
+      photo: photo ? (photo.startsWith('http') ? photo : `https://topdeck.gg${photo}`) : null,
+      details: {
+        handle
+      }
+    };
+
+    const statsMap = {
+      'totalTournaments': 'Tournaments',
+      'overallRecord': 'Record',
+      'overallWinRate': 'Win Rate',
+      'conversionRate': 'Conversion'
+    };
+
+    Object.entries(statsMap).forEach(([id, label]) => {
+      const val = $(`#${id}`).text().trim();
+      if (val) {
+        data.details[label] = val;
+      }
+    });
+
+    if (Object.keys(data.details).length === 1) {
+      $('.stats-container, .player-stats').each((i, el) => {
+        $(el).find('.stat').each((j, statEl) => {
+          const label = $(statEl).find('.label').text().trim();
+          const value = $(statEl).find('.value').text().trim();
+          if (label && value) {
+            data.details[label] = value;
+          }
+        });
+      });
+    }
+
+    return data;
+  }
+}
+
+module.exports = TopdeckFetcher;

package/src/fetchers/unityLeague.js

@@ -0,0 +1,100 @@
+const { request } = require('../utils/httpClient');
+const cheerio = require('cheerio');
+
+class UnityLeagueFetcher {
+  async fetchById(id) {
+    const url = `https://unityleague.gg/player/${id}/`;
+    try {
+      const { data } = await request(url);
+      return this.parseHtml(data, url);
+    } catch (error) {
+      console.error(`Error fetching Unity League player ${id}:`, error.message);
+      return null;
+    }
+  }
+
+  parseHtml(html, url) {
+    const $ = cheerio.load(html);
+    const name = $('h1.d-inline').text().trim();
+    let photo = $('.card-body img.img-fluid').first().attr('src');
+    if (photo && !photo.includes('player_profile')) {
+      photo = null;
+    }
+
+    const data = {
+      source: 'Unity League',
+      url,
+      name,
+      photo: photo ? (photo.startsWith('http') ? photo : `https://unityleague.gg${photo}`) : null,
+      details: {}
+    };
+
+    const headerFlag = $('.card-body i.fi').first();
+    if (headerFlag.length > 0) {
+      const classes = headerFlag.attr('class').split(' ');
+      const countryClass = classes.find(c => c.startsWith('fi-'));
+      if (countryClass) {
+        data.details.Country = countryClass.replace('fi-', '');
+      }
+    }
+
+    $('dt.small.text-muted').each((i, el) => {
+      const key = $(el).text().trim().replace(/:$/, '');
+      const dd = $(el).next('dd');
+      let value = dd.text().trim();
+
+      if (key === 'Country') {
+        const flagIcon = dd.find('i.fi');
+        if (flagIcon.length > 0) {
+          const classes = flagIcon.attr('class').split(' ');
+          const countryClass = classes.find(c => c.startsWith('fi-'));
+          if (countryClass) {
+            value = countryClass.replace('fi-', '');
+          }
+        }
+      }
+
+      data.details[key] = value;
+    });
+
+    const bioElement = $('.card-body > small.mt-2').first();
+    if (bioElement.length > 0) {
+      data.details.Bio = bioElement.text().trim();
+    }
+
+    const rankingTable = $('table.table-sm').first();
+    if (rankingTable.length) {
+      const headers = rankingTable.find('th').map((i, el) => $(el).text().trim()).get();
+      const values = rankingTable.find('tbody td').map((i, el) => $(el).text().trim()).get();
+
+      headers.forEach((header, i) => {
+        if (header && values[i]) {
+          let val = values[i];
+          if (val.startsWith('#')) {
+            val = val.substring(1);
+          }
+          data.details[`Rank ${header}`] = val;
+        }
+      });
+    }
+
+    // Extract tournament record and win rate
+    const overallRow = $('table.table tr').filter((i, el) => {
+      return $(el).find('td').first().text().trim() === 'Overall';
+    });
+
+    if (overallRow.length > 0) {
+      const cells = overallRow.find('td');
+      if (cells.length >= 3) {
+        const record = $(cells[1]).text().trim().replace(/\s+/g, '');
+        const winRate = $(cells[2]).text().trim();
+        data.details.Record = record;
+        data.details['Win Rate'] = winRate;
+      }
+    }
+
+    return data;
+  }
+}
+
+module.exports = UnityLeagueFetcher;

package/src/index.js

@@ -0,0 +1,87 @@
+const UnityLeagueFetcher = require('./fetchers/unityLeague');
+const MtgEloFetcher = require('./fetchers/mtgElo');
+const MeleeFetcher = require('./fetchers/melee');
+const TopdeckFetcher = require('./fetchers/topdeck');
+
+class PlayerInfoManager {
+  constructor() {
+    this.fetchers = {
+      unity: new UnityLeagueFetcher(),
+      mtgelo: new MtgEloFetcher(),
+      melee: new MeleeFetcher(),
+      topdeck: new TopdeckFetcher()
+    };
+  }
+
+  async getPlayerInfo(options) {
+    const results = [];
+
+    if (options.unityId) results.push(await this.fetchers.unity.fetchById(options.unityId));
+    if (options.mtgeloId) results.push(await this.fetchers.mtgelo.fetchById(options.mtgeloId));
+    if (options.meleeUser) results.push(await this.fetchers.melee.fetchById(options.meleeUser));
+    if (options.topdeckHandle) results.push(await this.fetchers.topdeck.fetchById(options.topdeckHandle));
+
+    const filteredResults = results.filter(r => r !== null);
+    return this.mergeData(filteredResults);
+  }
+
+  mergeData(results) {
+    const player = {
+      name: null,
+      photo: null,
+      general: {},
+      sources: {}
+    };
+
+    const seenUrls = new Set();
+
+    const winRates = [];
+
+    results.forEach(res => {
+      if (seenUrls.has(res.url)) return;
+      seenUrls.add(res.url);
+
+      if (!player.name && res.name) player.name = res.name;
+      if (!player.photo && res.photo) player.photo = res.photo;
+
+      if (res.details) {
+        if (res.details.Age && !player.general.Age) player.general.Age = res.details.Age;
+        if (res.details.Bio && !player.general.Bio) player.general.Bio = res.details.Bio;
+        if (res.details.Team && !player.general.Team) player.general.Team = res.details.Team;
+        if (res.details.Country && !player.general.Country) player.general.Country = res.details.Country;
+        if (res.details.Hometown && !player.general.Hometown) player.general.Hometown = res.details.Hometown;
+
+        const winRateStr = res.details['Win Rate'] || res.details.winRate;
+        if (winRateStr && typeof winRateStr === 'string') {
+          const winRate = parseFloat(winRateStr.replace('%', ''));
+          if (!isNaN(winRate)) {
+            winRates.push(winRate);
+          }
+        }
+      }
+
+      const sourceData = { ...res.details };
+      if (res.source === 'Unity League') {
+        delete sourceData.Age;
+        delete sourceData.Bio;
+        delete sourceData.Hometown;
+        delete sourceData.Team;
+        delete sourceData.Country;
+      }
+
+      player.sources[res.source] = {
+        url: res.url,
+        data: sourceData
+      };
+    });
+
+    if (winRates.length > 0) {
+      const avgWinRate = winRates.reduce((a, b) => a + b, 0) / winRates.length;
+      player.general['Win Rate'] = avgWinRate.toFixed(2) + '%';
+    }
+
+    return player;
+  }
+}
+
+module.exports = PlayerInfoManager;

package/src/utils/httpClient.js

@@ -0,0 +1,69 @@
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+
+function request(url, options = {}) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const protocol = parsedUrl.protocol === 'https:' ? https : http;
+    
+    const headers = {
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      ...options.headers
+    };
+
+    const requestOptions = {
+      method: options.method || 'GET',
+      headers: headers,
+      timeout: 30000,
+      ...options
+    };
+
+    const req = protocol.request(url, requestOptions, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        const redirectUrl = new URL(res.headers.location, url).href;
+        const maxRedirects = options.maxRedirects || 5;
+        if (maxRedirects > 0) {
+          return request(redirectUrl, { ...options, maxRedirects: maxRedirects - 1 })
+            .then(resolve)
+            .catch(reject);
+        } else {
+          return reject(new Error('Too many redirects'));
+        }
+      }
+
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          resolve({
+            data,
+            status: res.statusCode,
+            headers: res.headers
+          });
+        } else {
+          reject(new Error(`Request failed with status ${res.statusCode}`));
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      reject(err);
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timed out'));
+    });
+
+    if (options.body) {
+      req.write(options.body);
+    }
+    req.end();
+  });
+}
+
+module.exports = { request };