modforge-cli 0.1.9__tar.gz → 0.2.0__tar.gz

{modforge_cli-0.1.9 → modforge_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modforge-cli
-Version: 0.1.9
+Version: 0.2.0
 Summary: ModForge-CLI — a Modrinth-based Minecraft modpack builder
 License: MIT
 License-File: LICENSE

{modforge_cli-0.1.9 → modforge_cli-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "modforge-cli"
-version = "0.1.9"
+version = "0.2.0"
 description = "ModForge-CLI — a Modrinth-based Minecraft modpack builder"
 authors = [{ name = "Frank1o3", email = "jahdy1o3@gmail.com" }]
 license = { text = "MIT" }

{modforge_cli-0.1.9 → modforge_cli-0.2.0}/src/modforge_cli/__version__.py

@@ -1,5 +1,5 @@
 """
 Auto-generated file. DO NOT EDIT.
 """
-__version__ = "0.1.9"
+__version__ = "0.2.0"
 __author__ = "Frank1o3"

{modforge_cli-0.1.9 → modforge_cli-0.2.0}/src/modforge_cli/cli.py

@@ -5,7 +5,6 @@ from pathlib import Path
 import shutil
 import subprocess
 import sys
-from typing import Optional
 import urllib.request
 
 from pyfiglet import figlet_format
@@ -47,7 +46,7 @@ app = typer.Typer(
 console = Console()
 
 # Configuration
-FABRIC_LOADER_VERSION = "0.16.9"
+FABRIC_LOADER_VERSION = "0.18.4"
 CONFIG_PATH = Path.home() / ".config" / "ModForge-CLI"
 REGISTRY_PATH = CONFIG_PATH / "registry.json"
 MODRINTH_API = CONFIG_PATH / "modrinth_api.json"
@@ -78,7 +77,7 @@ ensure_config_file(POLICY_PATH, DEFAULT_POLICY_URL, "Policy", console)
 api = ModrinthAPIConfig(MODRINTH_API)
 
 
-def render_banner():
+def render_banner() -> None:
     """Renders a stylized banner"""
     width = console.width
     font = "slant" if width > 60 else "small"
@@ -108,13 +107,14 @@ def render_banner():
 @app.callback(invoke_without_command=True)
 def main_callback(
     ctx: typer.Context,
-    version: Optional[bool] = typer.Option(None, "--version", "-v", help="Show version and exit"),
-    verbose: Optional[bool] = typer.Option(None, "--verbose", help="Enable verbose logging"),
-):
+    version: bool | None = typer.Option(None, "--version", "-v", help="Show version and exit"),
+    verbose: bool | None = typer.Option(None, "--verbose", help="Enable verbose logging"),
+) -> None:
     """ModForge-CLI: A powerful Minecraft modpack manager for Modrinth."""
 
     if verbose:
         # Enable verbose logging
+
         logging.basicConfig(
             level=logging.DEBUG,
             format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
@@ -151,7 +151,7 @@ def setup(
     mc: str = "1.21.1",
     loader: str = "fabric",
     loader_version: str = FABRIC_LOADER_VERSION,
-):
+) -> None:
     """Initialize a new modpack project"""
     pack_dir = Path.cwd() / name
 
@@ -177,13 +177,22 @@ def setup(
     (pack_dir / "ModForge-CLI.json").write_text(manifest.model_dump_json(indent=4))
 
     # Create Modrinth index
+    # Map loader names to their dependency keys
+    loader_key_map = {
+        "fabric": "fabric-loader",
+        "quilt": "quilt-loader",
+        "forge": "forge",
+        "neoforge": "neoforge",
+    }
+    loader_key = loader_key_map.get(loader.lower(), loader.lower())
+
     index_data = {
         "formatVersion": 1,
         "game": "minecraft",
         "versionId": "1.0.0",
         "name": name,
-        "dependencies": {"minecraft": mc, loader: "*"},
-        "files": [],
+        "dependencies": {"minecraft": mc, loader_key: loader_version},
+        "files": [],  # Only for overrides, not mods
     }
     (pack_dir / "modrinth.index.json").write_text(json.dumps(index_data, indent=2))
 
@@ -197,7 +206,7 @@ def setup(
 
 
 @app.command()
-def add(name: str, project_type: str = "mod", pack_name: Optional[str] = None):
+def add(name: str, project_type: str = "mod", pack_name: str | None = None) -> None:
     """Add a project to the manifest"""
 
     if project_type not in ["mod", "resourcepack", "shaderpack"]:
@@ -219,7 +228,7 @@ def add(name: str, project_type: str = "mod", pack_name: Optional[str] = None):
     if pack_name not in registry:
         console.print(f"[red]Pack '{pack_name}' not found in registry[/red]")
         console.print("[yellow]Available packs:[/yellow]")
-        for p in registry.keys():
+        for p in registry:
             console.print(f"  - {p}")
         raise typer.Exit(1)
 
@@ -235,7 +244,7 @@ def add(name: str, project_type: str = "mod", pack_name: Optional[str] = None):
 
 
 @app.command()
-def resolve(pack_name: Optional[str] = None):
+def resolve(pack_name: str | None = None) -> None:
     """Resolve all mod dependencies"""
 
     # Auto-detect pack
@@ -257,7 +266,7 @@ def resolve(pack_name: Optional[str] = None):
 
     manifest = get_manifest(console, pack_path)
     if not manifest:
-        console.print(f"[red]Could not load manifest[/red]")
+        console.print("[red]Could not load manifest[/red]")
         raise typer.Exit(1)
 
     console.print(f"[cyan]Resolving dependencies for {pack_name}...[/cyan]")
@@ -275,7 +284,7 @@ def resolve(pack_name: Optional[str] = None):
         resolved_mods = asyncio.run(do_resolve())
     except Exception as e:
         console.print(f"[red]Resolution failed:[/red] {e}")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from e
 
     manifest.mods = sorted(list(resolved_mods))
     manifest_file.write_text(manifest.model_dump_json(indent=4))
@@ -284,7 +293,7 @@ def resolve(pack_name: Optional[str] = None):
 
 
 @app.command()
-def build(pack_name: Optional[str] = None):
+def build(pack_name: str | None = None) -> None:
     """Download all mods and dependencies"""
 
     if not pack_name:
@@ -318,11 +327,11 @@ def build(pack_name: Optional[str] = None):
         console.print("[green]✓ Build complete[/green]")
     except Exception as e:
         console.print(f"[red]Build failed:[/red] {e}")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from e
 
 
 @app.command()
-def export(pack_name: Optional[str] = None):
+def export(pack_name: str | None = None) -> None:
     """Create final .mrpack file"""
 
     if not pack_name:
@@ -358,6 +367,7 @@ def export(pack_name: Optional[str] = None):
 
         if not installer.exists():
             console.print("[yellow]Downloading Fabric installer...[/yellow]")
+            
 
             urllib.request.urlretrieve(FABRIC_INSTALLER_URL, installer)
 
@@ -377,15 +387,10 @@ def export(pack_name: Optional[str] = None):
                 loader_version=loader_version,
                 game_dir=pack_path,
             )
+            console.print(f"[green]✓ Fabric {loader_version} installed[/green]")
         except RuntimeError as e:
             console.print(f"[red]{e}[/red]")
-            raise typer.Exit(1)
-
-        # Update index
-        index_file = pack_path / "modrinth.index.json"
-        index = json.loads(index_file.read_text())
-        index["dependencies"]["fabric-loader"] = loader_version
-        index_file.write_text(json.dumps(index, indent=2))
+            raise typer.Exit(1) from e
 
         installer.unlink(missing_ok=True)
 
@@ -406,7 +411,7 @@ def export(pack_name: Optional[str] = None):
 
 
 @app.command()
-def remove(pack_name: str):
+def remove(pack_name: str) -> None:
     """Remove a modpack and unregister it"""
     registry = load_registry(REGISTRY_PATH)
 
@@ -442,7 +447,7 @@ def remove(pack_name: str):
 
 
 @app.command(name="ls")
-def list_projects():
+def list_projects() -> None:
     """List all registered modpacks"""
     registry = load_registry(REGISTRY_PATH)
 
@@ -462,7 +467,7 @@ def list_projects():
 
 
 @app.command()
-def doctor():
+def doctor() -> None:
     """Validate ModForge-CLI installation"""
     console.print("[bold cyan]Running diagnostics...[/bold cyan]\n")
 
@@ -471,11 +476,7 @@ def doctor():
     # Check Python version
 
     py_version = f"{sys.version_info.major}.{sys.version_info.minor}"
-    if sys.version_info >= (3, 10):
-        console.print(f"[green]✓[/green] Python {py_version}")
-    else:
-        console.print(f"[red]✗[/red] Python {py_version} (requires 3.10+)")
-        issues.append("Upgrade Python")
+    console.print(f"[green]✓[/green] Python {py_version}")
 
     # Check config files
     for name, path in [("API Config", MODRINTH_API), ("Policy", POLICY_PATH)]:
@@ -491,6 +492,7 @@ def doctor():
 
     # Check Java
     try:
+
         result = subprocess.run(["java", "-version"], capture_output=True, text=True, check=True)
         console.print("[green]✓[/green] Java installed")
     except (FileNotFoundError, subprocess.CalledProcessError):
@@ -508,16 +510,16 @@ def doctor():
 
 
 @app.command(name="self-update")
-def self_update_cmd():
+def self_update_cmd() -> None:
     """Update ModForge-CLI to latest version"""
     try:
         self_update(console)
     except Exception as e:
         console.print(f"[red]Update failed:[/red] {e}")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from e
 
 
-def main():
+def main() -> None:
     app()
 
 

modforge_cli-0.2.0/src/modforge_cli/core/downloader.py

@@ -0,0 +1,211 @@
+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())
+
+    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):
+            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 update modrinth.index.json dependencies.
+
+        Note: Modrinth launchers auto-download mods based on dependencies.
+        We download to mods/ folder for local use, but the index only needs
+        the version IDs in dependencies, not file paths.
+        """
+        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)
+
+        # Update dependencies section with correct loader version
+        self._update_dependencies()
+        self.index_file.write_text(json.dumps(self.index, indent=2))
+
+    def _update_dependencies(self) -> None:
+        """
+        Ensure dependencies section has correct MC version and loader.
+        This is what launchers use to setup the game.
+        """
+        if "dependencies" not in self.index:
+            self.index["dependencies"] = {}
+
+        # Set Minecraft version
+        self.index["dependencies"]["minecraft"] = self.mc_version
+
+        # Set loader (fabric-loader, forge, quilt-loader, neoforge)
+        loader_key_map = {
+            "fabric": "fabric-loader",
+            "quilt": "quilt-loader",
+            "forge": "forge",
+            "neoforge": "neoforge",
+        }
+
+        loader_key = loader_key_map.get(self.loader.lower(), self.loader.lower())
+
+        # Use "*" to let launcher pick latest compatible version
+        # Or you can specify exact version if available
+        self.index["dependencies"][loader_key] = "*"
+
+    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"]
+
+        # Skip if already downloaded and hash matches
+        if dest.exists():
+            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
+            else:
+                console.print(
+                    f"[yellow]Re-downloading {primary_file['filename']} (hash mismatch)[/yellow]"
+                )
+
+        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()
+        if sha1 != primary_file["hashes"]["sha1"]:
+            dest.unlink(missing_ok=True)  # Delete corrupted file
+            raise RuntimeError(
+                f"Hash mismatch for {primary_file['filename']}\n"
+                f"  Expected: {primary_file['hashes']['sha1']}\n"
+                f"  Got:      {sha1}"
+            )
+
+        console.print(
+            f"[green]✓[/green] {primary_file['filename']} "
+            f"[dim](v{version.get('version_number')}, {self.loader})[/dim]"
+        )

modforge_cli-0.1.9/src/modforge_cli/core/downloader.py

@@ -1,87 +0,0 @@
-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())
-
-    async def download_all(self, project_ids: Iterable[str]) -> None:
-        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)
-
-        self.index_file.write_text(json.dumps(self.index, indent=2))
-
-    async def _download_project(self, project_id: str) -> None:
-        # 1. Fetch compatible version
-        url = self.api.project_versions(project_id)
-
-        async with self.session.get(url) as r:
-            versions = await r.json()
-
-        if not versions:
-            console.print(f"[yellow]No compatible version for {project_id}[/yellow]")
-            return
-
-        version = versions[0]
-        file = next(f for f in version["files"] if f["primary"])
-
-        # 2. Download file
-        dest = self.output_dir / file["filename"]
-        async with self.session.get(file["url"]) as r:
-            data = await r.read()
-            dest.write_bytes(data)
-
-        # 3. Verify hash
-        sha1 = hashlib.sha1(data).hexdigest()
-        if sha1 != file["hashes"]["sha1"]:
-            raise RuntimeError(f"Hash mismatch for {file['filename']}")
-
-        # 4. Register in index
-        self.index["files"].append(
-            {
-                "path": f"mods/{file['filename']}",
-                "hashes": {"sha1": sha1},
-                "downloads": [file["url"]],
-                "fileSize": file["size"],
-            }
-        )