feat: add NeoForge version tracking

Add a custom parser that fetches versions from the NeoForge Maven API,
with fallback to the CreeperHost mirror. Handles both the old (<26)
and new (>=26) version-to-MC-version mapping schemes.

Author: Pyker

mod_polling/mods.json

@@ -34,6 +34,15 @@
             "slim": true
         }
     },
+    "NeoForge": {
+        "parser": "neoforge",
+        "category": "forge",
+        "active": true,
+        "neoforge": {
+            "url": "https://maven.neoforged.net/api/maven/versions/releases/net%2Fneoforged%2Fneoforge",
+            "fallback_url": "https://maven.creeperhost.net/api/maven/versions/releases/net%2Fneoforged%2Fneoforge"
+        }
+    },
     "OpenComputers": {
         "parser": "cfwidget",
         "active": true,

mod_polling/poller.py

@@ -409,6 +409,69 @@ async def check_buildcraft(self, mod):
 
         return {"mc": mc, "version": version}
 
+    async def check_neoforge(self, mod):
+        url = self.mods[mod]["neoforge"]["url"]
+        fallback_url = self.mods[mod]["neoforge"].get("fallback_url")
+
+        try:
+            jsonres = await self.fetch_json(url)
+        except Exception:
+            if not fallback_url:
+                raise
+            jsonres = await self.fetch_json(fallback_url)
+
+        result = {}
+
+        # Iterate newest first (API returns oldest first)
+        for neoforge_version in reversed(jsonres.get("versions", [])):
+            # Skip 0.x joke/test versions
+            if neoforge_version.startswith("0"):
+                continue
+
+            # Skip alpha versions
+            if "-alpha" in neoforge_version:
+                continue
+
+            # Skip snapshot builds (+ denotes MC snapshot identifier)
+            if "+" in neoforge_version:
+                continue
+
+            mc_version = self._neoforge_mc_version(neoforge_version)
+            is_beta = "-beta" in neoforge_version
+
+            if mc_version not in result:
+                result[mc_version] = {}
+
+            mc_entry = result[mc_version]
+
+            if is_beta:
+                # Only store beta as dev if no same-or-newer stable exists
+                if "dev" not in mc_entry and "version" not in mc_entry:
+                    mc_entry["dev"] = neoforge_version
+            else:
+                if "version" not in mc_entry:
+                    mc_entry["version"] = neoforge_version
+
+        return result
+
+    @staticmethod
+    def _neoforge_mc_version(neoforge_version):
+        """Derive the Minecraft version from a NeoForge version string.
+
+        <26: prepend "1." to first two parts (e.g. 21.1.222 -> 1.21.1)
+        >=26: first three parts, drop trailing .0 (e.g. 26.1.1.0-beta -> 26.1.1)
+        """
+        base = neoforge_version.split("-")[0]
+        parts = base.split(".")
+
+        if int(parts[0]) >= 26:
+            mc = parts[0] + "." + parts[1]
+            if parts[2] != "0":
+                mc += "." + parts[2]
+            return mc
+        else:
+            return "1." + parts[0] + "." + parts[1]
+
     def is_version_valid(self, version):
         return all(not regex.search(version) for regex in self.invalid_versions)
 

plugins/nemp.py

@@ -745,6 +745,8 @@ async def cmd_url(self, router, name, params, channel, userdata, rank):
             url = mod["forgejson"]["url"]
         elif func == "html":
             url = mod["html"]["url"]
+        elif func == "neoforge":
+            url = mod["neoforge"]["url"]
         else:
             url = None
 

scripts/test_regexes.py

@@ -382,6 +382,34 @@ async def check_custom_dead(session, mod_name, mod_data, compiled_regex, *, use_
     return DEAD, "Custom parser endpoint (likely dead)", None, [], []
 
 
+async def check_neoforge(session, mod_name, mod_data, compiled_regex, *, use_cache=False, all_files=False):
+    url = mod_data["neoforge"]["url"]
+    fallback_url = mod_data["neoforge"].get("fallback_url")
+
+    data = None
+    for attempt_url in [url, fallback_url]:
+        if not attempt_url:
+            continue
+        try:
+            async with session.get(attempt_url) as resp:
+                if resp.status >= 400:
+                    continue
+                data = await resp.json(content_type=None)
+                break
+        except Exception:
+            continue
+
+    if data is None:
+        return DEAD, "Both primary and fallback URLs failed", None, [], []
+
+    versions = data.get("versions", [])
+    if not versions:
+        return DEAD, "Empty versions list", None, [], []
+
+    samples = versions[-5:]
+    return PASS, f"Found {len(versions)} NeoForge versions", None, samples, []
+
+
 PARSER_MAP = {
     "cfwidget": check_curse,
     "jenkins": check_jenkins,
@@ -390,6 +418,7 @@ async def check_custom_dead(session, mod_name, mod_data, compiled_regex, *, use_
     "mcforge_v2": check_mcforge2,
     "html": check_html,
     "buildcraft": check_buildcraft,
+    "neoforge": check_neoforge,
 }
 
 

tests/test_mods_json.py

@@ -51,3 +51,14 @@ def test_forgejson_parser(self):
 
             assert "forgejson" in mod_info, msg
             assert "url" in mod_info["forgejson"], msg
+
+    def test_neoforge_parser(self):
+        for mod, mod_info in self.mods.items():
+            if mod_info["parser"] != "neoforge":
+                continue
+
+            msg = f"Mod {mod!r} has missing NeoForge parser information"
+
+            assert "neoforge" in mod_info, msg
+            assert "url" in mod_info["neoforge"], msg
+            assert "fallback_url" in mod_info["neoforge"], msg

tests/test_poller_parsers.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from mod_polling.poller import NEMPException
+from mod_polling.poller import ModPoller, NEMPException
 
 
 class TestCheckMCForge2:
@@ -270,3 +270,126 @@ async def test_buildcraft(self, mod_poller):
         result = await mod_poller.check_buildcraft("BuildCraft")
         assert result["mc"] == "1.12.2"
         assert result["version"] == "7.99.24"
+
+
+class TestCheckNeoForge:
+    NEOFORGE_MOD = {
+        "parser": "neoforge",
+        "neoforge": {
+            "url": "https://maven.neoforged.net/api/maven/versions/releases/net%2Fneoforged%2Fneoforge",
+            "fallback_url": "https://maven.creeperhost.net/api/maven/versions/releases/net%2Fneoforged%2Fneoforge",
+        },
+    }
+
+    async def test_multi_mc_versions(self, mod_poller):
+        """Both <26 and >=26 version schemes resolve correctly."""
+        mod_poller.mods["NeoForge"] = self.NEOFORGE_MOD
+        mod_poller.fetch_json = AsyncMock(
+            return_value={
+                "versions": [
+                    "20.2.3-beta",
+                    "20.2.86",
+                    "21.1.0-beta",
+                    "21.1.222",
+                    "26.1.0.1-beta",
+                    "26.1.1.0-beta",
+                ]
+            }
+        )
+        result = await mod_poller.check_neoforge("NeoForge")
+        assert result["1.20.2"]["version"] == "20.2.86"
+        assert result["1.21.1"]["version"] == "21.1.222"
+        assert result["26.1"]["dev"] == "26.1.0.1-beta"
+        assert result["26.1.1"]["dev"] == "26.1.1.0-beta"
+
+    async def test_beta_only(self, mod_poller):
+        """MC version with only beta releases gets dev, no version."""
+        mod_poller.mods["NeoForge"] = self.NEOFORGE_MOD
+        mod_poller.fetch_json = AsyncMock(
+            return_value={"versions": ["26.1.1.0-beta"]}
+        )
+        result = await mod_poller.check_neoforge("NeoForge")
+        assert result["26.1.1"] == {"dev": "26.1.1.0-beta"}
+
+    async def test_stable_suppresses_older_beta(self, mod_poller):
+        """When a stable release exists, older betas are not stored as dev."""
+        mod_poller.mods["NeoForge"] = self.NEOFORGE_MOD
+        mod_poller.fetch_json = AsyncMock(
+            return_value={
+                "versions": [
+                    "21.1.0-beta",
+                    "21.1.1-beta",
+                    "21.1.50",
+                    "21.1.100",
+                ]
+            }
+        )
+        result = await mod_poller.check_neoforge("NeoForge")
+        assert result["1.21.1"]["version"] == "21.1.100"
+        assert "dev" not in result["1.21.1"]
+
+    async def test_skips_alpha_zero_and_snapshot(self, mod_poller):
+        """Alpha, 0.x, and + (snapshot) versions are excluded."""
+        mod_poller.mods["NeoForge"] = self.NEOFORGE_MOD
+        mod_poller.fetch_json = AsyncMock(
+            return_value={
+                "versions": [
+                    "0.25w14craftmine.3-beta",
+                    "21.1.0-alpha.1",
+                    "21.1.5+snapshot-1",
+                    "21.1.100",
+                ]
+            }
+        )
+        result = await mod_poller.check_neoforge("NeoForge")
+        assert "0.25" not in result
+        assert result == {"1.21.1": {"version": "21.1.100"}}
+
+    async def test_fallback_on_primary_failure(self, mod_poller):
+        """Falls back to CreeperHost mirror when primary fails."""
+        mod_poller.mods["NeoForge"] = self.NEOFORGE_MOD
+        mod_poller.fetch_json = AsyncMock(
+            side_effect=[
+                Exception("primary down"),
+                {"versions": ["21.1.50"]},
+            ]
+        )
+        result = await mod_poller.check_neoforge("NeoForge")
+        assert result["1.21.1"]["version"] == "21.1.50"
+        assert mod_poller.fetch_json.call_count == 2
+
+    async def test_fallback_not_attempted_without_url(self, mod_poller):
+        """Without fallback_url, primary failure propagates."""
+        mod_poller.mods["NeoForge"] = {
+            "parser": "neoforge",
+            "neoforge": {"url": "https://maven.neoforged.net/..."},
+        }
+        mod_poller.fetch_json = AsyncMock(side_effect=Exception("primary down"))
+        with pytest.raises(Exception, match="primary down"):
+            await mod_poller.check_neoforge("NeoForge")
+
+    async def test_empty_versions(self, mod_poller):
+        """Empty versions list returns empty result."""
+        mod_poller.mods["NeoForge"] = self.NEOFORGE_MOD
+        mod_poller.fetch_json = AsyncMock(return_value={"versions": []})
+        result = await mod_poller.check_neoforge("NeoForge")
+        assert result == {}
+
+
+class TestNeoForgeMcVersion:
+    """Unit tests for the MC version derivation helper."""
+
+    def test_old_scheme(self):
+        assert ModPoller._neoforge_mc_version("21.1.222") == "1.21.1"
+
+    def test_old_scheme_beta(self):
+        assert ModPoller._neoforge_mc_version("20.2.3-beta") == "1.20.2"
+
+    def test_new_scheme_minor_zero(self):
+        assert ModPoller._neoforge_mc_version("26.1.0.19-beta") == "26.1"
+
+    def test_new_scheme_minor_nonzero(self):
+        assert ModPoller._neoforge_mc_version("26.1.1.0-beta") == "26.1.1"
+
+    def test_new_scheme_stable(self):
+        assert ModPoller._neoforge_mc_version("26.1.1.5") == "26.1.1"