modforge-cli 0.2.3__py3-none-any.whl

modforge_cli/core/downloader.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Iterable
+import hashlib
+import json
+from pathlib import Path
+
+import aiohttp
+from rich.console import Console
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
+
+from modforge_cli.api import ModrinthAPIConfig
+
+console = Console()
+
+
+class ModDownloader:
+    def __init__(
+        self,
+        api: ModrinthAPIConfig,
+        mc_version: str,
+        loader: str,
+        output_dir: Path,
+        index_file: Path,
+        session: aiohttp.ClientSession,
+    ):
+        self.api = api
+        self.mc_version = mc_version
+        self.loader = loader
+        self.output_dir = output_dir
+        self.index_file = index_file
+        self.session = session
+
+        self.index = json.loads(index_file.read_text())
+
+        # Ensure files array exists
+        if "files" not in self.index:
+            self.index["files"] = []
+
+    def _select_compatible_version(self, versions: list[dict]) -> dict | None:
+        """
+        Select the most appropriate version based on:
+        1. Loader compatibility (fabric/forge/quilt/neoforge)
+        2. Minecraft version
+        3. Version type (prefer release > beta > alpha)
+        """
+        # Normalize loader name for comparison
+        loader_lower = self.loader.lower()
+
+        # Filter versions that match both MC version and loader
+        compatible = []
+        for v in versions:
+            # Check if MC version matches
+            if self.mc_version not in v.get("game_versions", []):
+                continue
+
+            # Check if loader matches (case-insensitive)
+            loaders = [l.lower() for l in v.get("loaders", [])]
+            if loader_lower not in loaders:
+                continue
+
+            compatible.append(v)
+
+        if not compatible:
+            return None
+
+        # Prioritize by version type: release > beta > alpha
+        version_priority = {"release": 3, "beta": 2, "alpha": 1}
+
+        def version_score(v) -> int:
+            vtype = v.get("version_type", "alpha")
+            return version_priority.get(vtype, 0)
+
+        # Sort by version type, then by date (newest first)
+        compatible.sort(key=lambda v: (version_score(v), v.get("date_published", "")), reverse=True)
+
+        return compatible[0]
+
+    async def download_all(self, project_ids: Iterable[str]) -> None:
+        """
+        Download all mods and register them in modrinth.index.json.
+
+        The index format follows Modrinth's standard:
+        - files: array of all mods with hashes, URLs, and metadata
+        - dependencies: MC version and loader version
+        """
+        tasks = [self._download_project(pid) for pid in project_ids]
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[bold cyan]{task.description}"),
+            BarColumn(),
+            TextColumn("{task.completed}/{task.total}"),
+            console=console,
+        ) as progress:
+            task_id = progress.add_task("Downloading mods", total=len(tasks))
+            for coro in asyncio.as_completed(tasks):
+                await coro
+                progress.advance(task_id)
+
+        # Write updated index
+        self.index_file.write_text(json.dumps(self.index, indent=2))
+
+    async def _download_project(self, project_id: str) -> None:
+        # 1. Fetch all versions for this project
+        url = self.api.project_versions(project_id)
+
+        try:
+            async with self.session.get(url) as r:
+                if r.status != 200:
+                    console.print(
+                        f"[red]Failed to fetch versions for {project_id}: HTTP {r.status}[/red]"
+                    )
+                    return
+                versions = await r.json()
+        except Exception as e:
+            console.print(f"[red]Error fetching {project_id}: {e}[/red]")
+            return
+
+        if not versions:
+            console.print(f"[yellow]No versions found for {project_id}[/yellow]")
+            return
+
+        # 2. Select compatible version
+        version = self._select_compatible_version(versions)
+
+        if not version:
+            console.print(
+                f"[yellow]No compatible version for {project_id}[/yellow]\n"
+                f"[dim]  Required: MC {self.mc_version}, Loader: {self.loader}[/dim]"
+            )
+            return
+
+        # 3. Find primary file
+        files = version.get("files", [])
+        primary_file = next((f for f in files if f.get("primary")), None)
+
+        if not primary_file and files:
+            # Fallback to first file if no primary is marked
+            primary_file = files[0]
+
+        if not primary_file:
+            console.print(
+                f"[yellow]No files found for {project_id} version {version.get('version_number')}[/yellow]"
+            )
+            return
+
+        # 4. Download file to mods/ directory
+        dest = self.output_dir / primary_file["filename"]
+
+        # Check if already registered in index
+        existing_entry = next(
+            (f for f in self.index["files"] if f["path"] == f"mods/{primary_file['filename']}"),
+            None,
+        )
+
+        if existing_entry and dest.exists():
+            # Verify hash matches
+            existing_hash = hashlib.sha1(dest.read_bytes()).hexdigest()
+            if existing_hash == primary_file["hashes"]["sha1"]:
+                console.print(f"[dim]✓ {primary_file['filename']} (cached)[/dim]")
+                return
+
+        # Download the file
+        try:
+            async with self.session.get(primary_file["url"]) as r:
+                if r.status != 200:
+                    console.print(
+                        f"[red]Failed to download {primary_file['filename']}: HTTP {r.status}[/red]"
+                    )
+                    return
+                data = await r.read()
+                dest.write_bytes(data)
+        except Exception as e:
+            console.print(f"[red]Download error for {primary_file['filename']}: {e}[/red]")
+            return
+
+        # 5. Verify hash
+        sha1 = hashlib.sha1(data).hexdigest()
+        sha512 = hashlib.sha512(data).hexdigest()
+
+        if sha1 != primary_file["hashes"]["sha1"]:
+            dest.unlink(missing_ok=True)
+            raise RuntimeError(
+                f"Hash mismatch for {primary_file['filename']}\n"
+                f"  Expected: {primary_file['hashes']['sha1']}\n"
+                f"  Got:      {sha1}"
+            )
+
+        # 6. Register in index (Modrinth format)
+        file_entry = {
+            "path": f"mods/{primary_file['filename']}",
+            "hashes": {"sha1": sha1, "sha512": sha512},
+            "downloads": [primary_file["url"]],
+            "fileSize": primary_file["size"],
+        }
+
+        # Remove existing entry if present (update scenario)
+        self.index["files"] = [f for f in self.index["files"] if f["path"] != file_entry["path"]]
+
+        # Add new entry
+        self.index["files"].append(file_entry)
+
+        console.print(
+            f"[green]✓[/green] {primary_file['filename']} "
+            f"[dim](v{version.get('version_number')}, {self.loader})[/dim]"
+        )

modforge_cli/core/models.py

@@ -0,0 +1,66 @@
+from typing import 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,161 @@
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Iterable
+import json
+from pathlib import Path
+from typing import TypedDict
+from urllib.parse import urlparse
+from urllib.request import urlopen
+
+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,184 @@
+import asyncio
+from collections import deque
+from collections.abc import Iterable
+
+import aiohttp
+
+from modforge_cli.api import ModrinthAPIConfig
+from modforge_cli.core.models import ProjectVersion, ProjectVersionList, SearchResult
+from modforge_cli.core.policy import ModPolicy
+
+try:
+    from modforge_cli.__version__ import __author__, __version__
+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
+
+    async def _search_project(self, slug: str, session: aiohttp.ClientSession) -> str | None:
+        """Search for a project by slug and return its project_id"""
+        url = self.api.search(
+            slug,
+            game_versions=[self.mc_version],
+            loaders=[self.loader],
+        )
+
+        try:
+            async with session.get(url) as response:
+                data = SearchResult.model_validate_json(await response.text())
+
+            for hit in data.hits:
+                if hit.project_type != "mod":
+                    continue
+                if self.mc_version not in hit.versions:
+                    continue
+                return hit.project_id
+        except Exception as e:
+            print(f"Warning: Failed to search for '{slug}': {e}")
+
+        return None
+
+    async def _fetch_versions(
+        self, project_id: str, session: aiohttp.ClientSession
+    ) -> list[ProjectVersion]:
+        """Fetch all versions for a project"""
+        url = self.api.project_versions(project_id)
+
+        try:
+            async with session.get(url) as response:
+                return ProjectVersionList.validate_json(await response.text())
+        except Exception as e:
+            print(f"Warning: Failed to fetch versions for '{project_id}': {e}")
+            return []
+
+    async def resolve(self, mods: Iterable[str], session: aiohttp.ClientSession) -> set[str]:
+        """
+        Asynchronously resolve all mod dependencies.
+
+        Args:
+            mods: Initial list of mod slugs
+            session: Active aiohttp session
+
+        Returns:
+            Set of resolved project IDs
+        """
+        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 (parallel) ----
+        search_tasks = []
+        slugs_to_search = []
+
+        for slug in expanded:
+            if slug not in search_cache:
+                slugs_to_search.append(slug)
+                search_tasks.append(self._search_project(slug, session))
+
+        if search_tasks:
+            search_results = await asyncio.gather(*search_tasks, return_exceptions=True)
+
+            for slug, result in zip(slugs_to_search, search_results):
+                if isinstance(result, Exception):
+                    print(f"Error searching for '{slug}': {result}")
+                    search_cache[slug] = None
+                else:
+                    search_cache[slug] = result
+
+        # Add found projects to queue
+        for slug in expanded:
+            project_id = search_cache.get(slug)
+            if project_id and project_id not in resolved:
+                resolved.add(project_id)
+                queue.append(project_id)
+
+        # ---- Phase 2: dependency resolution (batched) ----
+        BATCH_SIZE = 10
+
+        while queue:
+            # Process in batches to avoid overwhelming the API
+            batch = []
+            for _ in range(min(len(queue), BATCH_SIZE)):
+                if queue:
+                    batch.append(queue.popleft())
+
+            # Fetch versions for batch in parallel
+            version_tasks = []
+            projects_to_fetch = []
+
+            for pid in batch:
+                if pid not in version_cache:
+                    projects_to_fetch.append(pid)
+                    version_tasks.append(self._fetch_versions(pid, session))
+
+            if version_tasks:
+                version_results = await asyncio.gather(*version_tasks, return_exceptions=True)
+
+                for pid, result in zip(projects_to_fetch, version_results, strict=False):
+                    if isinstance(result, Exception):
+                        print(f"Error fetching versions for '{pid}': {result}")
+                        version_cache[pid] = []
+                    else:
+                        version_cache[pid] = result
+
+            # Process dependencies
+            for pid in batch:
+                versions = version_cache.get(pid, [])
+                version = self._select_version(versions)
+
+                if not version:
+                    print(f"Warning: No compatible version found for '{pid}'")
+                    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") and dep_id not in resolved:
+                        resolved.add(dep_id)
+                        queue.append(dep_id)
+
+        del queue, expanded, search_cache, version_cache
+        return resolved