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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "modforge-cli"
-version = "0.1.7"
+version = "0.1.9"
 description = "ModForge-CLI — a Modrinth-based Minecraft modpack builder"
 authors = [{ name = "Frank1o3", email = "jahdy1o3@gmail.com" }]
 license = { text = "MIT" }
@@ -48,7 +48,7 @@ dev = [
 package-mode = true
 
 [tool.poetry.scripts]
-modforge = "modforge_cli.__main__:main"
+modforge-cli = "modforge_cli.__main__:main"
 
 [project.urls]
 Homepage = "https://frank1o3.github.io/ModForge-CLI/"

{modforge_cli-0.1.7 → modforge_cli-0.1.9}/src/modforge_cli/__init__.py

@@ -1,5 +1,3 @@
 """
 ModForge-CLI - A CLI tool for building and managing Minecraft modpacks
 """
-
-__version__ = "0.1.0"

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

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

{modforge_cli-0.1.7 → modforge_cli-0.1.9}/src/modforge_cli/api/__init__.py

@@ -4,4 +4,4 @@ api package - Exposes the Modrinth API client globally.
 
 from .modrinth import ModrinthAPIConfig
 
-__all__ = ["ModrinthAPIConfig"]
+__all__ = ["ModrinthAPIConfig"]

{modforge_cli-0.1.7 → modforge_cli-0.1.9}/src/modforge_cli/api/modrinth.py

@@ -21,9 +21,7 @@ class ModrinthAPIConfig:
 
     def _load_config(self) -> None:
         if not self.config_path.exists():
-            raise FileNotFoundError(
-                f"Modrinth API config not found: {self.config_path}"
-            )
+            raise FileNotFoundError(f"Modrinth API config not found: {self.config_path}")
 
         with open(self.config_path, "r", encoding="utf-8") as f:
             data = json.load(f)
@@ -123,9 +121,7 @@ class ModrinthAPIConfig:
         return self.build_url(self.endpoints["projects"]["project"], id=project_id)
 
     def project_versions(self, project_id: str) -> str:
-        return self.build_url(
-            self.endpoints["projects"]["project_versions"], id=project_id
-        )
+        return self.build_url(self.endpoints["projects"]["project_versions"], id=project_id)
 
     def project_dependencies(self, project_id: str) -> str:
         return self.build_url(self.endpoints["projects"]["dependencies"], id=project_id)
@@ -137,9 +133,7 @@ class ModrinthAPIConfig:
         return self.build_url(self.endpoints["projects"]["icon"], id=project_id)
 
     def check_following(self, project_id: str) -> str:
-        return self.build_url(
-            self.endpoints["projects"]["check_following"], id=project_id
-        )
+        return self.build_url(self.endpoints["projects"]["check_following"], id=project_id)
 
     # === Versions ===
 
@@ -158,9 +152,7 @@ class ModrinthAPIConfig:
         return self.build_url(self.endpoints["versions"]["file_by_hash"], hash=hash_)
 
     def versions_by_hash(self, hash_: str) -> str:
-        return self.build_url(
-            self.endpoints["versions"]["versions_by_hash"], hash=hash_
-        )
+        return self.build_url(self.endpoints["versions"]["versions_by_hash"], hash=hash_)
 
     def latest_version_for_hash(self, hash_: str, algorithm: str = "sha1") -> str:
         return self.build_url(

modforge_cli-0.1.9/src/modforge_cli/cli.py

@@ -0,0 +1,525 @@
+import asyncio
+import json
+import logging
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+from typing import Optional
+import urllib.request
+
+from pyfiglet import figlet_format
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+from rich.table import Table
+from rich.text import Text
+import typer
+
+from modforge_cli.api import ModrinthAPIConfig
+from modforge_cli.core import (
+    Manifest,
+    ModPolicy,
+    ModResolver,
+    ensure_config_file,
+    get_api_session,
+    get_manifest,
+    install_fabric,
+    load_registry,
+    perform_add,
+    run,
+    save_registry_atomic,
+    self_update,
+    setup_crash_logging,
+)
+
+# Import version info
+try:
+    from modforge_cli.__version__ import __author__, __version__
+except ImportError:
+    __version__ = "unknown"
+    __author__ = "Frank1o3"
+
+app = typer.Typer(
+    add_completion=False,
+    no_args_is_help=False,
+)
+console = Console()
+
+# Configuration
+FABRIC_LOADER_VERSION = "0.16.9"
+CONFIG_PATH = Path.home() / ".config" / "ModForge-CLI"
+REGISTRY_PATH = CONFIG_PATH / "registry.json"
+MODRINTH_API = CONFIG_PATH / "modrinth_api.json"
+POLICY_PATH = CONFIG_PATH / "policy.json"
+
+# Use versioned URLs to prevent breaking changes
+GITHUB_RAW = "https://raw.githubusercontent.com/Frank1o3/ModForge-CLI"
+VERSION_TAG = "v0.1.8"  # Update this with each release
+
+FABRIC_INSTALLER_URL = (
+    "https://maven.fabricmc.net/net/fabricmc/fabric-installer/1.1.1/fabric-installer-1.1.1.jar"
+)
+FABRIC_INSTALLER_SHA256 = (
+    "8fa465768bd7fc452e08c3a1e5c8a6b4b5f6a4e64bc7def47f89d8d3a6f4e7b8"  # Replace with actual hash
+)
+
+DEFAULT_MODRINTH_API_URL = f"{GITHUB_RAW}/{VERSION_TAG}/configs/modrinth_api.json"
+DEFAULT_POLICY_URL = f"{GITHUB_RAW}/{VERSION_TAG}/configs/policy.json"
+
+# Setup crash logging
+LOG_DIR = setup_crash_logging()
+
+# Ensure configs exist
+ensure_config_file(MODRINTH_API, DEFAULT_MODRINTH_API_URL, "Modrinth API", console)
+ensure_config_file(POLICY_PATH, DEFAULT_POLICY_URL, "Policy", console)
+
+# Initialize API
+api = ModrinthAPIConfig(MODRINTH_API)
+
+
+def render_banner():
+    """Renders a stylized banner"""
+    width = console.width
+    font = "slant" if width > 60 else "small"
+
+    ascii_art = figlet_format("ModForge-CLI", font=font)
+    banner_text = Text(ascii_art, style="bold cyan")
+
+    info_line = Text.assemble(
+        (" ⛏  ", "yellow"),
+        (f"v{__version__}", "bold white"),
+        (" | ", "dim"),
+        ("Created by ", "italic white"),
+        (f"{__author__}", "bold magenta"),
+    )
+
+    console.print(
+        Panel(
+            Text.assemble(banner_text, "\n", info_line),
+            border_style="blue",
+            padding=(1, 2),
+            expand=False,
+        ),
+        justify="left",
+    )
+
+
+@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"),
+):
+    """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",
+            handlers=[
+                logging.FileHandler(LOG_DIR / f"modforge-{__version__}.log"),
+                logging.StreamHandler(),
+            ],
+        )
+
+    if version:
+        console.print(f"ModForge-CLI Version: [bold cyan]{__version__}[/bold cyan]")
+        raise typer.Exit()
+
+    if ctx.invoked_subcommand is None:
+        render_banner()
+        console.print("\n[bold yellow]Usage:[/bold yellow] ModForge-CLI [COMMAND] [ARGS]...")
+        console.print("\n[bold cyan]Core Commands:[/bold cyan]")
+        console.print("  [green]setup[/green]    Initialize a new modpack project")
+        console.print("  [green]ls[/green]       List all registered projects")
+        console.print("  [green]add[/green]      Add a mod/resource/shader to manifest")
+        console.print("  [green]resolve[/green]  Resolve all dependencies")
+        console.print("  [green]build[/green]    Download files and setup loader")
+        console.print("  [green]export[/green]   Create the final .mrpack")
+        console.print("  [green]remove[/green]   Remove a modpack project")
+        console.print("\n[bold cyan]Utility:[/bold cyan]")
+        console.print("  [green]self-update[/green]  Update ModForge-CLI")
+        console.print("  [green]doctor[/green]       Validate installation")
+        console.print("\nRun [white]ModForge-CLI --help[/white] for details.\n")
+
+
+@app.command()
+def setup(
+    name: str,
+    mc: str = "1.21.1",
+    loader: str = "fabric",
+    loader_version: str = FABRIC_LOADER_VERSION,
+):
+    """Initialize a new modpack project"""
+    pack_dir = Path.cwd() / name
+
+    if pack_dir.exists():
+        console.print(f"[red]Error:[/red] Directory '{name}' already exists")
+        raise typer.Exit(1)
+
+    pack_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create standard structure
+    for folder in [
+        "mods",
+        "overrides/resourcepacks",
+        "overrides/shaderpacks",
+        "overrides/config",
+        "overrides/config/openloader/data",
+        "versions",
+    ]:
+        (pack_dir / folder).mkdir(parents=True, exist_ok=True)
+
+    # Create manifest
+    manifest = Manifest(name=name, minecraft=mc, loader=loader, loader_version=loader_version)
+    (pack_dir / "ModForge-CLI.json").write_text(manifest.model_dump_json(indent=4))
+
+    # Create Modrinth index
+    index_data = {
+        "formatVersion": 1,
+        "game": "minecraft",
+        "versionId": "1.0.0",
+        "name": name,
+        "dependencies": {"minecraft": mc, loader: "*"},
+        "files": [],
+    }
+    (pack_dir / "modrinth.index.json").write_text(json.dumps(index_data, indent=2))
+
+    # Register project
+    registry = load_registry(REGISTRY_PATH)
+    registry[name] = str(pack_dir.absolute())
+    save_registry_atomic(registry, REGISTRY_PATH)
+
+    console.print(f"[green]✓ Project '{name}' created at {pack_dir}[/green]")
+    console.print(f"[dim]Run 'cd {name}' to enter the project[/dim]")
+
+
+@app.command()
+def add(name: str, project_type: str = "mod", pack_name: Optional[str] = None):
+    """Add a project to the manifest"""
+
+    if project_type not in ["mod", "resourcepack", "shaderpack"]:
+        console.print(f"[red]Invalid type:[/red] {project_type}")
+        console.print("[yellow]Valid types:[/yellow] mod, resourcepack, shaderpack")
+        raise typer.Exit(1)
+
+    # Auto-detect pack if not specified
+    if not pack_name:
+        manifest = get_manifest(console, Path.cwd())
+        if manifest:
+            pack_name = manifest.name
+        else:
+            console.print("[red]No manifest found in current directory[/red]")
+            console.print("[yellow]Specify --pack-name or run from project directory[/yellow]")
+            raise typer.Exit(1)
+
+    registry = load_registry(REGISTRY_PATH)
+    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():
+            console.print(f"  - {p}")
+        raise typer.Exit(1)
+
+    pack_path = Path(registry[pack_name])
+    manifest_file = pack_path / "ModForge-CLI.json"
+
+    manifest = get_manifest(console, pack_path)
+    if not manifest:
+        console.print(f"[red]Could not load manifest at {manifest_file}[/red]")
+        raise typer.Exit(1)
+
+    asyncio.run(perform_add(api, name, manifest, project_type, console, manifest_file))
+
+
+@app.command()
+def resolve(pack_name: Optional[str] = None):
+    """Resolve all mod dependencies"""
+
+    # Auto-detect pack
+    if not pack_name:
+        manifest = get_manifest(console, Path.cwd())
+        if manifest:
+            pack_name = manifest.name
+        else:
+            console.print("[red]No manifest found[/red]")
+            raise typer.Exit(1)
+
+    registry = load_registry(REGISTRY_PATH)
+    if pack_name not in registry:
+        console.print(f"[red]Pack '{pack_name}' not found[/red]")
+        raise typer.Exit(1)
+
+    pack_path = Path(registry[pack_name])
+    manifest_file = pack_path / "ModForge-CLI.json"
+
+    manifest = get_manifest(console, pack_path)
+    if not manifest:
+        console.print(f"[red]Could not load manifest[/red]")
+        raise typer.Exit(1)
+
+    console.print(f"[cyan]Resolving dependencies for {pack_name}...[/cyan]")
+
+    policy = ModPolicy(POLICY_PATH)
+    resolver = ModResolver(
+        policy=policy, api=api, mc_version=manifest.minecraft, loader=manifest.loader
+    )
+
+    async def do_resolve():
+        async with await get_api_session() as session:
+            return await resolver.resolve(manifest.mods, session)
+
+    try:
+        resolved_mods = asyncio.run(do_resolve())
+    except Exception as e:
+        console.print(f"[red]Resolution failed:[/red] {e}")
+        raise typer.Exit(1)
+
+    manifest.mods = sorted(list(resolved_mods))
+    manifest_file.write_text(manifest.model_dump_json(indent=4))
+
+    console.print(f"[green]✓ Resolved {len(manifest.mods)} mods[/green]")
+
+
+@app.command()
+def build(pack_name: Optional[str] = None):
+    """Download all mods and dependencies"""
+
+    if not pack_name:
+        manifest = get_manifest(console, Path.cwd())
+        if manifest:
+            pack_name = manifest.name
+        else:
+            console.print("[red]No manifest found[/red]")
+            raise typer.Exit(1)
+
+    registry = load_registry(REGISTRY_PATH)
+    if pack_name not in registry:
+        console.print(f"[red]Pack '{pack_name}' not found[/red]")
+        raise typer.Exit(1)
+
+    pack_path = Path(registry[pack_name])
+    manifest = get_manifest(console, pack_path)
+    if not manifest:
+        raise typer.Exit(1)
+
+    pack_root = pack_path
+    mods_dir = pack_root / "mods"
+    index_file = pack_root / "modrinth.index.json"
+
+    mods_dir.mkdir(exist_ok=True)
+
+    console.print(f"[cyan]Building {manifest.name}...[/cyan]")
+
+    try:
+        asyncio.run(run(api, manifest, mods_dir, index_file))
+        console.print("[green]✓ Build complete[/green]")
+    except Exception as e:
+        console.print(f"[red]Build failed:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def export(pack_name: Optional[str] = None):
+    """Create final .mrpack file"""
+
+    if not pack_name:
+        manifest = get_manifest(console, Path.cwd())
+        if manifest:
+            pack_name = manifest.name
+        else:
+            console.print("[red]No manifest found[/red]")
+            raise typer.Exit(1)
+
+    registry = load_registry(REGISTRY_PATH)
+    if pack_name not in registry:
+        console.print(f"[red]Pack '{pack_name}' not found[/red]")
+        raise typer.Exit(1)
+
+    pack_path = Path(registry[pack_name])
+    manifest = get_manifest(console, pack_path)
+    if not manifest:
+        raise typer.Exit(1)
+
+    loader_version = manifest.loader_version or FABRIC_LOADER_VERSION
+
+    console.print("[cyan]Exporting modpack...[/cyan]")
+
+    mods_dir = pack_path / "mods"
+    if not mods_dir.exists() or not any(mods_dir.iterdir()):
+        console.print("[red]No mods found. Run 'ModForge-CLI build' first[/red]")
+        raise typer.Exit(1)
+
+    # Install loader if needed
+    if manifest.loader == "fabric":
+        installer = pack_path / ".fabric-installer.jar"
+
+        if not installer.exists():
+            console.print("[yellow]Downloading Fabric installer...[/yellow]")
+
+            urllib.request.urlretrieve(FABRIC_INSTALLER_URL, installer)
+
+            # Verify hash (security)
+            # Note: Update FABRIC_INSTALLER_SHA256 with actual hash
+            # actual_hash = hashlib.sha256(installer.read_bytes()).hexdigest()
+            # if actual_hash != FABRIC_INSTALLER_SHA256:
+            #     console.print("[red]Installer hash mismatch![/red]")
+            #     installer.unlink()
+            #     raise typer.Exit(1)
+
+        console.print("[yellow]Installing Fabric...[/yellow]")
+        try:
+            install_fabric(
+                installer=installer,
+                mc_version=manifest.minecraft,
+                loader_version=loader_version,
+                game_dir=pack_path,
+            )
+        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))
+
+        installer.unlink(missing_ok=True)
+
+    # Create .mrpack
+    zip_path = pack_path.parent / f"{pack_name}.mrpack"
+    shutil.make_archive(
+        base_name=str(zip_path.with_suffix("")),
+        format="zip",
+        root_dir=pack_path,
+    )
+
+    # Rename .zip to .mrpack
+    zip_file = pack_path.parent / f"{pack_name}.zip"
+    if zip_file.exists():
+        zip_file.rename(zip_path)
+
+    console.print(f"[green bold]✓ Exported to {zip_path}[/green bold]")
+
+
+@app.command()
+def remove(pack_name: str):
+    """Remove a modpack and unregister it"""
+    registry = load_registry(REGISTRY_PATH)
+
+    if pack_name not in registry:
+        console.print(f"[red]Pack '{pack_name}' not found[/red]")
+        raise typer.Exit(1)
+
+    pack_path = Path(registry[pack_name])
+
+    console.print(
+        Panel.fit(
+            f"[bold red]This will permanently delete:[/bold red]\n\n"
+            f"[white]{pack_name}[/white]\n"
+            f"[dim]{pack_path}[/dim]",
+            title="⚠️  Destructive Action",
+            border_style="red",
+        )
+    )
+
+    if not Confirm.ask("Are you sure?", default=False):
+        console.print("Aborted.")
+        raise typer.Exit()
+
+    # Remove directory
+    if pack_path.exists():
+        shutil.rmtree(pack_path)
+
+    # Update registry
+    del registry[pack_name]
+    save_registry_atomic(registry, REGISTRY_PATH)
+
+    console.print(f"[green]✓ Removed {pack_name}[/green]")
+
+
+@app.command(name="ls")
+def list_projects():
+    """List all registered modpacks"""
+    registry = load_registry(REGISTRY_PATH)
+
+    if not registry:
+        console.print("[yellow]No projects registered yet[/yellow]")
+        console.print("[dim]Run 'ModForge-CLI setup <name>' to create one[/dim]")
+        return
+
+    table = Table(title="ModForge-CLI Projects", header_style="bold magenta")
+    table.add_column("Name", style="cyan")
+    table.add_column("Location", style="dim")
+
+    for name, path in registry.items():
+        table.add_row(name, path)
+
+    console.print(table)
+
+
+@app.command()
+def doctor():
+    """Validate ModForge-CLI installation"""
+    console.print("[bold cyan]Running diagnostics...[/bold cyan]\n")
+
+    issues = []
+
+    # 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")
+
+    # Check config files
+    for name, path in [("API Config", MODRINTH_API), ("Policy", POLICY_PATH)]:
+        if path.exists():
+            console.print(f"[green]✓[/green] {name}: {path}")
+        else:
+            console.print(f"[red]✗[/red] {name} missing")
+            issues.append(f"Reinstall {name}")
+
+    # Check registry
+    registry = load_registry(REGISTRY_PATH)
+    console.print(f"[green]✓[/green] Registry: {len(registry)} projects")
+
+    # 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):
+        console.print("[yellow]![/yellow] Java not found (needed for Fabric)")
+        issues.append("Install Java 17+")
+
+    # Summary
+    console.print()
+    if issues:
+        console.print("[yellow]Issues found:[/yellow]")
+        for issue in issues:
+            console.print(f"  - {issue}")
+    else:
+        console.print("[green bold]✓ All checks passed![/green bold]")
+
+
+@app.command(name="self-update")
+def self_update_cmd():
+    """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)
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,39 @@
+from .downloader import ModDownloader
+from .models import Hit, Manifest, ProjectVersion, ProjectVersionList, SearchResult
+from .policy import ModPolicy
+from .resolver import ModResolver
+from .utils import (
+    detect_install_method,
+    ensure_config_file,
+    get_api_session,
+    get_manifest,
+    install_fabric,
+    load_registry,
+    perform_add,
+    run,
+    save_registry_atomic,
+    self_update,
+    setup_crash_logging,
+)
+
+__all__ = [
+    "ModPolicy",
+    "ModResolver",
+    "Manifest",
+    "Hit",
+    "SearchResult",
+    "ProjectVersion",
+    "ProjectVersionList",
+    "ModDownloader",
+    "ensure_config_file",
+    "install_fabric",
+    "run",
+    "get_api_session",
+    "get_manifest",
+    "self_update",
+    "perform_add",
+    "detect_install_method",
+    "load_registry",
+    "save_registry_atomic",
+    "setup_crash_logging",
+]

{modforge_cli-0.1.7 → modforge_cli-0.1.9}/src/modforge_cli/core/downloader.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 import asyncio
+from collections.abc import Iterable
 import hashlib
 import json
 from pathlib import Path
-from typing import Iterable
 
 import aiohttp
 from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
 
 from modforge_cli.api import ModrinthAPIConfig
 
@@ -34,7 +34,7 @@ class ModDownloader:
 
         self.index = json.loads(index_file.read_text())
 
-    async def download_all(self, project_ids: Iterable[str]):
+    async def download_all(self, project_ids: Iterable[str]) -> None:
         tasks = [self._download_project(pid) for pid in project_ids]
 
         with Progress(
@@ -51,11 +51,9 @@ class ModDownloader:
 
         self.index_file.write_text(json.dumps(self.index, indent=2))
 
-    async def _download_project(self, project_id: str):
+    async def _download_project(self, project_id: str) -> None:
         # 1. Fetch compatible version
-        url = self.api.project_versions(
-            project_id
-        )
+        url = self.api.project_versions(project_id)
 
         async with self.session.get(url) as r:
             versions = await r.json()