modforge-cli 0.1.5__py3-none-any.whl

modforge_cli/core/models.py

@@ -0,0 +1,72 @@
+from typing import List, Dict, Literal
+from pydantic import BaseModel, Field, TypeAdapter
+
+
+class BaseAPIModel(BaseModel):
+    model_config = {"extra": "ignore"}
+
+
+class Manifest(BaseModel):
+    name: str
+    minecraft: str
+    loader: str
+    loader_version: str | None = None
+    mods: List[str] = Field(default_factory=list)
+    resourcepacks: List[str] = Field(default_factory=list)
+    shaderpacks: List[str] = Field(default_factory=list)
+
+
+class Hit(BaseAPIModel):
+    project_id: str
+    project_type: str
+    slug: str
+    categories: List[str] = Field(default_factory=list)
+    versions: List[str] = Field(default_factory=list)
+
+
+class SearchResult(BaseAPIModel):
+    hits: List[Hit] = Field(default_factory=list)
+
+
+class Dependency(BaseAPIModel):
+    dependency_type: (
+        Literal["required", "optional", "incompatible", "embedded"] | None
+    ) = None
+    file_name: str | None = None
+    project_id: str | None = None
+    version_id: str | None = None
+
+
+class File(BaseAPIModel):
+    id: str | None = None
+    hashes: Dict[str, str] = Field(default_factory=dict)
+    url: str | None = None
+    filename: str | None = None
+    primary: bool | None = None
+    size: int | None = None
+    file_type: str | None = None
+
+
+class ProjectVersion(BaseAPIModel):
+    id: str
+    project_id: str
+    version_number: str
+    version_type: str
+    dependencies: List[Dependency] = Field(default_factory=list)
+    files: List[File] = Field(default_factory=list)
+    game_versions: List[str] = Field(default_factory=list)
+    loaders: List[str] = Field(default_factory=list)
+
+    @property
+    def is_release(self) -> bool:
+        return self.version_type == "release"
+
+
+ProjectVersionList = TypeAdapter(List[ProjectVersion])
+
+__all__ = [
+    "Manifest",
+    "SearchResult",
+    "ProjectVersion",
+    "ProjectVersionList",
+]

modforge_cli/core/policy.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Dict, Iterable, List, Set, TypedDict
+from urllib.parse import urlparse
+from urllib.request import urlopen
+from collections import deque
+
+from jsonschema import ValidationError, validate
+
+
+class NormalizedModRule(TypedDict):
+    conflicts: Set[str]
+    sub_mods: Set[str]
+
+
+NormalizedPolicyRules = Dict[str, NormalizedModRule]
+
+
+class PolicyError(RuntimeError):
+    pass
+
+
+# -------- schema cache (performance + offline safety) --------
+_SCHEMA_CACHE: Dict[str, dict] = {}
+
+
+def _load_schema(schema_ref: str, base_path: Path) -> dict:
+    if schema_ref in _SCHEMA_CACHE:
+        return _SCHEMA_CACHE[schema_ref]
+
+    parsed = urlparse(schema_ref)
+
+    try:
+        if parsed.scheme in ("http", "https", "file"):
+            with urlopen(schema_ref) as resp:
+                schema = json.load(resp)
+        else:
+            schema_path = (base_path.parent / schema_ref).resolve()
+            if not schema_path.exists():
+                raise PolicyError(f"Schema not found: {schema_path}")
+            schema = json.loads(schema_path.read_text())
+    except Exception as e:
+        raise PolicyError(f"Failed to load schema '{schema_ref}': {e}") from e
+
+    _SCHEMA_CACHE[schema_ref] = schema
+    return schema
+
+
+class ModPolicy:
+    """
+    Enforces mod compatibility rules:
+    - removes conflicts
+    - injects recommended sub-mods
+    """
+
+    def __init__(self, policy_path: str | Path = "configs/policy.json"):
+        self.policy_path = policy_path if isinstance(policy_path, Path) else Path(policy_path)
+        self.rules: NormalizedPolicyRules = {}
+        self.schema_ref: str | None = None
+
+        self._load()
+        self._validate()
+        self._normalize()
+
+    # ---------- loading & validation ----------
+
+    def _load(self) -> None:
+        try:
+            raw = json.loads(self.policy_path.read_text())
+
+            self.schema_ref = raw.get("$schema")
+            if not self.schema_ref:
+                raise PolicyError("Policy file missing $schema field")
+
+            raw.pop("$schema", None)
+            self.rules = raw
+
+            del raw
+        except Exception as e:
+            raise PolicyError(f"Failed to load policy: {e}") from e
+
+    def _validate(self) -> None:
+        try:
+            schema = _load_schema(self.schema_ref, self.policy_path)
+            validate(instance=self.rules, schema=schema)
+            del schema
+        except ValidationError as e:
+            raise PolicyError(f"Policy schema violation:\n{e.message}") from e
+        except Exception as e:
+            raise PolicyError(f"Schema validation failed: {e}") from e
+
+    def _normalize(self) -> None:
+        """
+        Normalize rule values into sets for O(1) lookups
+        """
+        for rule in self.rules.values():
+            rule["conflicts"] = set(rule.get("conflicts", []))
+            rule["sub_mods"] = set(rule.get("sub_mods", []))
+
+    # ---------- public API ----------
+
+    def apply(self, mods: Iterable[str]) -> Set[str]:
+        """
+        Apply policy to a mod set.
+        Recursively adds sub-mods and removes conflicts.
+        Explicit mods always win over implicit ones.
+        """
+        explicit: Set[str] = set(mods)
+        active: Set[str] = set(explicit)
+        implicit: Set[str] = set()
+
+        queue = deque(active)
+
+        # 1. Expand sub-mods recursively
+        while queue:
+            current = queue.popleft()
+            rule = self.rules.get(current)
+            if not rule:
+                continue
+
+            for sub in rule["sub_mods"]:
+                if sub not in active:
+                    active.add(sub)
+                    implicit.add(sub)
+                    queue.append(sub)
+
+        # 2. Resolve conflicts (implicit loses first)
+        for mod in sorted(active):
+            rule = self.rules.get(mod)
+            if not rule:
+                continue
+
+            for conflict in rule["conflicts"]:
+                if conflict in active:
+                    if conflict in explicit and mod in explicit:
+                        raise PolicyError(
+                            f"Explicit mod conflict: {mod} ↔ {conflict}"
+                        )
+
+                    if conflict in implicit:
+                        active.remove(conflict)
+                        implicit.discard(conflict)
+
+        del queue, explicit, implicit
+        return active
+
+    def diff(self, mods: Iterable[str]) -> Dict[str, List[str]]:
+        """
+        Show what would change without applying.
+        """
+        original = set(mods)
+        final = self.apply(mods)
+
+        diff = {
+            "added": sorted(final - original),
+            "removed": sorted(original - final),
+        }
+
+        del original, final
+        return diff

modforge_cli/core/resolver.py

@@ -0,0 +1,134 @@
+from typing import Iterable, Set
+from collections import deque
+
+from modforge_cli.core.policy import ModPolicy
+from modforge_cli.core.models import SearchResult, ProjectVersionList, ProjectVersion
+from modforge_cli.api import ModrinthAPIConfig
+from requests import get
+
+
+try:
+    from modforge_cli.__version__ import __version__, __author__
+except ImportError:
+    __version__ = "unknown"
+    __author__ = "Frank1o3"
+
+
+class ModResolver:
+    def __init__(
+        self,
+        *,
+        policy: ModPolicy,
+        api: ModrinthAPIConfig,
+        mc_version: str,
+        loader: str,
+    ) -> None:
+        self.policy = policy
+        self.api = api
+        self.mc_version = mc_version
+        self.loader = loader
+
+        self._headers = {
+            "User-Agent": f"{__author__}/ModForge-CLI/{__version__}"
+        }
+
+    def _select_version(self, versions: list[ProjectVersion]) -> ProjectVersion | None:
+        """
+        Prefer:
+        1. Release versions
+        2. Matching MC + loader
+        """
+        for v in versions:
+            if (
+                v.is_release
+                and self.mc_version in v.game_versions
+                and self.loader in v.loaders
+            ):
+                return v
+
+        for v in versions:
+            if (
+                self.mc_version in v.game_versions
+                and self.loader in v.loaders
+            ):
+                return v
+
+        return None
+
+    def resolve(self, mods: Iterable[str]) -> Set[str]:
+        expanded = self.policy.apply(mods)
+
+        resolved: Set[str] = set()
+        queue: deque[str] = deque()
+
+        search_cache: dict[str, str | None] = {}
+        version_cache: dict[str, list[ProjectVersion]] = {}
+
+        # ---- Phase 1: slug → project_id ----
+        for slug in expanded:
+            if slug not in search_cache:
+                url = self.api.search(
+                    slug,
+                    game_versions=[self.mc_version],
+                    loaders=[self.loader],
+                )
+                response = get(url, headers=self._headers)
+                data = SearchResult.model_validate_json(response.text)
+
+                project_id = None
+                for hit in data.hits:
+                    if hit.project_type != "mod":
+                        continue
+                    if self.mc_version not in hit.versions:
+                        continue
+                    project_id = hit.project_id
+                    break
+
+                search_cache[slug] = project_id
+                del url, response, data
+
+            project_id = search_cache[slug]
+            if project_id and project_id not in resolved:
+                resolved.add(project_id)
+                queue.append(project_id)
+
+        # ---- Phase 2: dependency resolution ----
+        while queue:
+            pid = queue.popleft()
+
+            if pid not in version_cache:
+                url = self.api.project_versions(pid)
+                response = get(url, headers=self._headers)
+                versions = ProjectVersionList.validate_json(response.text)
+                version_cache[pid] = versions
+                del url, response
+            else:
+                versions = version_cache[pid]
+
+            version = self._select_version(versions)
+            if not version:
+                continue
+
+            for dep in version.dependencies:
+                dtype = dep.dependency_type
+                dep_id = dep.project_id
+
+                if not dep_id:
+                    continue
+
+                if dtype == "incompatible":
+                    raise RuntimeError(
+                        f"Incompatible dependency detected: {pid} ↔ {dep_id}"
+                    )
+
+                if dtype in ("required", "optional"):
+                    if dep_id not in resolved:
+                        resolved.add(dep_id)
+                        queue.append(dep_id)
+
+                # embedded deps are intentionally ignored
+
+            del versions, version, pid
+
+        del queue, expanded, search_cache, version_cache
+        return resolved

modforge_cli-0.1.5.dist-info/METADATA

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: modforge-cli
+Version: 0.1.5
+Summary: ModForge-CLI — a Modrinth-based Minecraft modpack builder
+License: MIT
+License-File: LICENSE
+Author: Frank1o3
+Author-email: jahdy1o3@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Dist: aiofiles (>=25.1.0,<26.0.0)
+Requires-Dist: aiohttp (>=3.13.3,<4.0.0)
+Requires-Dist: jsonschema (>=4.25.1,<5.0.0)
+Requires-Dist: pydantic (>=2.12.5,<3.0.0)
+Requires-Dist: pyfiglet (>=1.0.4,<2.0.0)
+Requires-Dist: pyzipper (>=0.3.6,<0.4.0)
+Requires-Dist: requests (>=2.32.5,<3.0.0)
+Requires-Dist: rich (>=14.2.0,<15.0.0)
+Requires-Dist: typer (>=0.21.1,<0.22.0)
+Project-URL: Homepage, https://frank1o3.github.io/ModForge-CLI/
+Project-URL: Repository, https://github.com/Frank1o3/ModForge-CLI
+Description-Content-Type: text/markdown
+
+# ModForge-CLI ⛏
+
+[![Python 3.13+](https://img.shields.io/badge/python-3.13%2B-blue)](https://www.python.org/)
+[![MIT License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![Modrinth API v2](https://img.shields.io/badge/Modrinth-API%20v2-orange)](https://docs.modrinth.com/api-spec)
+
+**ModForge-CLI** is a powerful CLI tool for building and managing custom Minecraft modpacks using the Modrinth API v2.
+
+Search for projects, fetch versions, validate manifests, download mods with hash checks, and generate complete files — all from the terminal.
+
+Ideal for modpack developers, server admins, and automation scripts.
+
+## Terminal Banner
+
+When you run ModForge-CLI, you'll be greeted with this colorful Minecraft-themed banner
+
+## Key Features
+
+- **Modrinth API v2 Integration**: Search projects, list versions, fetch metadata in bulk.
+- **Modpack Management**: Read/validate `modrinth.index.json`, build packs from metadata.
+- **Validation**: Full JSON Schema checks + optional Pydantic models for strict typing.
+
+## Installation
+
+Requires **Python 3.13+**.
+
+**Recommended (Poetry)**:
+
+```bash
+poetry install
+```
+
+**Alternative (pip)**:
+
+```bash
+pip install -r requirements.txt
+```
+

modforge_cli-0.1.5.dist-info/RECORD

@@ -0,0 +1,16 @@
+modforge_cli/__init__.py,sha256=vfUV68-GslDHLhtm2mME6LC2_9lXqFLKNGylG54A-fQ,102
+modforge_cli/__main__.py,sha256=1atZnKiKAP03RIuBu9nl2XQioTQFjfaeq5O4OfsQNto,133
+modforge_cli/__version__.py,sha256=ksmUbJNIJvzvPWdmuIuY2Q1VcoeYHpVGSoC-JbAKCqk,88
+modforge_cli/api/__init__.py,sha256=2Yv8rwwndMqnYOHNWkPPdYhPGItN04w1vhx-oDId8K0,137
+modforge_cli/api/modrinth.py,sha256=vOiPld6DyPJuFxcmsc6CxmqwbdT4XL7smRsu2TrS8DA,7883
+modforge_cli/cli.py,sha256=SU9dSTYubTsHQ1t6e_m0G6HgW7zF3h1TKof10r-xT4Q,17411
+modforge_cli/core/__init__.py,sha256=_MWEHe9Kqeq93g6WXxL9Jy8jS0-eDdtdrbHHpV1O91Q,318
+modforge_cli/core/downloader.py,sha256=L0Y7zosFSSaLIDRHeBiuyfWnByKV6OedxUCE1fG1Zr0,2608
+modforge_cli/core/models.py,sha256=a-8Ua7rxDo6jChSPK4whPD13Kj2mF89IAArX24rvddc,1828
+modforge_cli/core/policy.py,sha256=LdQ005muAAuawTD6AYjqNDWUkWnc5fdgJMEqlBmRsjM,4810
+modforge_cli/core/resolver.py,sha256=fhVDl1zTJTD4AkWko8y1H2m1ArGnSUQyogaEJ925oCA,4076
+modforge_cli-0.1.5.dist-info/METADATA,sha256=7GHMur_0ZujqKWvLZHt1D6IRRKZxR8W5eh5HgH8rPos,2468
+modforge_cli-0.1.5.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+modforge_cli-0.1.5.dist-info/entry_points.txt,sha256=JxVNWD_fF0JwwJ_OTdfCYZ5-1mAFH0XqUSiARvf5oRA,55
+modforge_cli-0.1.5.dist-info/licenses/LICENSE,sha256=SAuHlb0YymKIXKAXl0lwgwwu31REY-3oBdLARIObBbs,1065
+modforge_cli-0.1.5.dist-info/RECORD,,

modforge_cli-0.1.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

modforge_cli-0.1.5.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+modforge=modforge_cli.__main__:main
+

modforge_cli-0.1.5.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Frank1o3
+
+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.