modforge-cli 0.2.3__py3-none-any.whl

modforge_cli/__init__.py

@@ -0,0 +1,7 @@
+"""
+CLI package for ModForge-CLI
+"""
+
+from . import main
+
+__all__ = ["main"]

modforge_cli/__main__.py

@@ -0,0 +1,132 @@
+"""
+Main CLI entry point - Registers all commands
+"""
+
+import logging
+
+from pyfiglet import figlet_format
+from rich.panel import Panel
+from rich.text import Text
+import typer
+
+from modforge_cli.cli import export, modpack, project, setup, sklauncher, utils
+from modforge_cli.cli.shared import (
+    DEFAULT_MODRINTH_API_URL,
+    DEFAULT_POLICY_URL,
+    MODRINTH_API,
+    POLICY_PATH,
+    console,
+    get_version_info,
+)
+from modforge_cli.core import ensure_config_file, setup_crash_logging
+
+# Get version info
+__version__, __author__ = get_version_info()
+
+# Create main app
+app = typer.Typer(
+    add_completion=False,
+    no_args_is_help=False,
+)
+
+# 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)
+
+
+def render_banner() -> None:
+    """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: 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",
+            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]validate[/green]    Check .mrpack for issues")
+        console.print("  [green]sklauncher[/green]  Create SKLauncher profile (no .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")
+
+
+# Register all command groups
+app.command()(setup.setup)
+app.add_typer(project.app, name="project", help="Project management commands")
+app.command("ls")(project.list_projects)
+app.command()(project.remove)
+app.command()(modpack.add)
+app.command()(modpack.resolve)
+app.command()(modpack.build)
+app.command()(export.export)
+app.command()(export.validate)
+app.command()(sklauncher.sklauncher)
+app.command()(utils.doctor)
+app.command("self-update")(utils.self_update_cmd)
+
+
+def main() -> None:
+    """Main entry point"""
+    app()
+
+
+if __name__ == "__main__":
+    main()

modforge_cli/__version__.py

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

modforge_cli/api/__init__.py

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

modforge_cli/api/modrinth.py

@@ -0,0 +1,210 @@
+"""
+api/modrith_api.py - Modrinth API v2 URL builder using modrinth_api.json
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from urllib.parse import quote_plus
+
+
+class ModrinthAPIConfig:
+    """Loads modrinth_api.json and builds Modrinth API URLs."""
+
+    def __init__(self, config_path: str | Path = "configs/modrinth_api.json"):
+        self.config_path = config_path if isinstance(config_path, Path) else Path(config_path)
+        self.base_url: str = ""
+        self.endpoints: Dict[str, Any] = {}
+        self._load_config()
+
+    def _load_config(self) -> None:
+        if not self.config_path.exists():
+            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)
+
+        self.base_url = data.get("BASE_URL", "").rstrip("/")
+        if not self.base_url:
+            raise ValueError("BASE_URL missing in modrinth_api.json")
+
+        self.endpoints = data.get("ENDPOINTS", {})
+        if not isinstance(self.endpoints, Dict):
+            raise ValueError("ENDPOINTS section is invalid")
+
+    def build_url(self, template: str, **kwargs: str) -> str:
+        """Format a template string with kwargs and prepend base URL."""
+        try:
+            path = template.format(**kwargs)
+            return f"{self.base_url}{path}"
+        except KeyError as e:
+            raise ValueError(f"Missing URL parameter: {e}")
+
+    # === Search ===
+
+    def search(
+        self,
+        query: Optional[str] = None,
+        facets: Optional[List[List[str]] | str] = None,
+        categories: Optional[List[str]] = None,
+        loaders: Optional[List[str]] = None,
+        game_versions: Optional[List[str]] = None,
+        license_: Optional[str] = None,
+        project_type: Optional[str] = None,
+        offset: Optional[int] = None,
+        limit: Optional[int] = 10,
+        index: Optional[str] = "relevance",
+    ) -> str:
+        """
+        Build the Modrinth search URL with query parameters.
+
+        Docs: https://docs.modrinth.com/api-spec#endpoints-search
+
+        Facets format: [[inner AND], [inner AND]] = outer OR
+        Example: [["categories:performance"], ["project_type:mod"]]
+
+        Args:
+            query: Search term (e.g., "sodium")
+            facets: Advanced filters as list of lists or JSON string
+            categories: Filter by categories (e.g., ["performance"])
+            loaders: Filter by loaders (e.g., ["fabric", "quilt"])
+            game_versions: Filter by Minecraft versions (e.g., ["1.21.1"])
+            license_: Filter by license (e.g., "MIT")
+            project_type: "mod", "resourcepack", "shader", "modpack", "datapack"
+            offset: Pagination offset
+            limit: Results per page (max 100)
+            index: Sort by "relevance", "downloads", "updated", "newest"
+
+        Returns:
+            Full search URL with query parameters
+        """
+        base = self.build_url(self.endpoints["search"])
+        params = []
+        if query:
+            params.append(f"query={quote_plus(query)}")
+
+        facets_array = []
+        if facets:
+            if isinstance(facets, str):
+                params.append(f"facets={quote_plus(facets)}")
+            else:
+                facets_array.extend(facets)
+
+        if project_type:
+            facets_array.append([f"project_type:{project_type}"])
+        if categories:
+            [facets_array.append([f"categories:{c}"]) for c in categories]
+        if loaders:
+            facets_array.append([f"categories:{l}" for l in loaders])
+        if game_versions:
+            facets_array.append([f"versions:{v}" for v in game_versions])
+        if license_:
+            facets_array.append([f"license:{license_}"])
+
+        if facets_array and not (isinstance(facets, str)):
+            params.append(f"facets={quote_plus(json.dumps(facets_array))}")
+
+        if offset is not None:
+            params.append(f"offset={offset}")
+        if limit is not None:
+            params.append(f"limit={min(limit, 100)}")
+        if index:
+            params.append(f"index={index}")
+
+        return f"{base}?{'&'.join(params)}" if params else base
+
+    # === Projects ===
+
+    def project(self, project_id: str) -> str:
+        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)
+
+    def project_dependencies(self, project_id: str) -> str:
+        return self.build_url(self.endpoints["projects"]["dependencies"], id=project_id)
+
+    def project_gallery(self, project_id: str) -> str:
+        return self.build_url(self.endpoints["projects"]["gallery"], id=project_id)
+
+    def project_icon(self, project_id: str) -> str:
+        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)
+
+    # === Versions ===
+
+    def version(self, version_id: str) -> str:
+        return self.build_url(self.endpoints["versions"]["version"], id=version_id)
+
+    def version_files(self, version_id: str) -> str:
+        return self.build_url(self.endpoints["versions"]["files"], id=version_id)
+
+    def version_file_download(self, version_id: str, filename: str) -> str:
+        return self.build_url(
+            self.endpoints["versions"]["download"], id=version_id, filename=filename
+        )
+
+    def file_by_hash(self, hash_: str) -> str:
+        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_)
+
+    def latest_version_for_hash(self, hash_: str, algorithm: str = "sha1") -> str:
+        return self.build_url(
+            self.endpoints["versions"]["latest_for_hash"], hash=hash_, algo=algorithm
+        )
+
+    # === Tags ===
+
+    def categories(self) -> str:
+        return self.build_url(self.endpoints["tags"]["categories"])
+
+    def loaders(self) -> str:
+        return self.build_url(self.endpoints["tags"]["loaders"])
+
+    def game_versions(self) -> str:
+        return self.build_url(self.endpoints["tags"]["game_versions"])
+
+    def licenses(self) -> str:
+        return self.build_url(self.endpoints["tags"]["licenses"])
+
+    def environments(self) -> str:
+        return self.build_url(self.endpoints["tags"]["environments"])
+
+    # === Teams ===
+
+    def team(self, team_id: str) -> str:
+        return self.build_url(self.endpoints["teams"]["team"], id=team_id)
+
+    def team_members(self, team_id: str) -> str:
+        return self.build_url(self.endpoints["teams"]["members"], id=team_id)
+
+    # === User ===
+
+    def user(self, user_id: str) -> str:
+        return self.build_url(self.endpoints["user"]["user"], id=user_id)
+
+    def user_projects(self, user_id: str) -> str:
+        return self.build_url(self.endpoints["user"]["user_projects"], id=user_id)
+
+    def user_notifications(self, user_id: str) -> str:
+        return self.build_url(self.endpoints["user"]["notifications"], id=user_id)
+
+    def user_avatar(self, user_id: str) -> str:
+        return self.build_url(self.endpoints["user"]["avatar"], id=user_id)
+
+    # === Bulk ===
+
+    def bulk_projects(self) -> str:
+        return self.build_url(self.endpoints["bulk"]["projects"])
+
+    def bulk_versions(self) -> str:
+        return self.build_url(self.endpoints["bulk"]["versions"])
+
+    def bulk_version_files(self) -> str:
+        return self.build_url(self.endpoints["bulk"]["version_files"])

modforge_cli/cli/__init__.py

@@ -0,0 +1,7 @@
+"""
+Commands package - Exports all command groups
+"""
+
+from . import export, modpack, project, setup, sklauncher, utils
+
+__all__ = ["setup", "project", "modpack", "export", "sklauncher", "utils"]

modforge_cli/cli/export.py

@@ -0,0 +1,246 @@
+"""
+Export and validation commands
+"""
+
+import json
+from pathlib import Path
+import shutil
+import tempfile
+import zipfile
+from zipfile import ZIP_DEFLATED, ZipFile
+
+import typer
+
+from modforge_cli.cli.shared import REGISTRY_PATH, console
+from modforge_cli.core import get_manifest, load_registry
+
+app = typer.Typer()
+
+
+@app.command()
+def export(pack_name: str | None = None) -> 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)
+
+    console.print("[cyan]Exporting modpack...[/cyan]")
+
+    mods_dir = pack_path / "mods"
+    index_file = pack_path / "modrinth.index.json"
+
+    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)
+
+    if not index_file.exists():
+        console.print("[red]No modrinth.index.json found[/red]")
+        raise typer.Exit(1)
+
+    # Validate index has files
+    index_data = json.loads(index_file.read_text())
+    if not index_data.get("files"):
+        console.print("[yellow]Warning: No files registered in index[/yellow]")
+        console.print("[yellow]This might cause issues. Run 'ModForge-CLI build' again.[/yellow]")
+
+    # Create .mrpack
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_path = Path(tmpdir)
+
+        # Copy modrinth.index.json to root
+        shutil.copy2(index_file, tmp_path / "modrinth.index.json")
+
+        # Copy overrides if they exist
+        overrides_src = pack_path / "overrides"
+        if overrides_src.exists():
+            overrides_dst = tmp_path / "overrides"
+            shutil.copytree(overrides_src, overrides_dst)
+            console.print("[green]✓ Copied overrides[/green]")
+
+        # Create .mrpack
+        mrpack_path = pack_path.parent / f"{pack_name}.mrpack"
+
+        with ZipFile(mrpack_path, "w", ZIP_DEFLATED) as zipf:
+            # Add modrinth.index.json at root
+            zipf.write(tmp_path / "modrinth.index.json", "modrinth.index.json")
+
+            # Add overrides folder if exists
+            if overrides_src.exists():
+                for file_path in (tmp_path / "overrides").rglob("*"):
+                    if file_path.is_file():
+                        arcname = str(file_path.relative_to(tmp_path))
+                        zipf.write(file_path, arcname)
+
+        console.print(f"[green bold]✓ Exported to {mrpack_path}[/green bold]")
+
+        # Show summary
+        file_count = len(index_data.get("files", []))
+        console.print("\n[cyan]Summary:[/cyan]")
+        console.print(f"  Files registered: {file_count}")
+        console.print(f"  Minecraft: {index_data['dependencies'].get('minecraft')}")
+
+        # Show loader
+        for loader in ["fabric-loader", "quilt-loader", "forge", "neoforge"]:
+            if loader in index_data["dependencies"]:
+                console.print(f"  Loader: {loader} {index_data['dependencies'][loader]}")
+
+        console.print("\n[dim]Import this in SKLauncher, Prism, ATLauncher, etc.[/dim]")
+
+
+@app.command()
+def validate(mrpack_file: str | None = None) -> None:
+    """Validate .mrpack file for launcher compatibility"""
+
+    if not mrpack_file:
+        # Look for .mrpack in current directory
+        mrpacks = list(Path.cwd().glob("*.mrpack"))
+        if not mrpacks:
+            console.print("[red]No .mrpack file found in current directory[/red]")
+            console.print("[yellow]Usage: ModForge-CLI validate <file.mrpack>[/yellow]")
+            raise typer.Exit(1)
+        mrpack_path = mrpacks[0]
+    else:
+        mrpack_path = Path(mrpack_file)
+
+    if not mrpack_path.exists():
+        console.print(f"[red]File not found: {mrpack_path}[/red]")
+        raise typer.Exit(1)
+
+    console.print(f"[cyan]Validating {mrpack_path.name}...[/cyan]\n")
+
+    issues = []
+    warnings = []
+
+    try:
+        with zipfile.ZipFile(mrpack_path, "r") as z:
+            files = z.namelist()
+
+            # Check for modrinth.index.json
+            if "modrinth.index.json" not in files:
+                console.print("[red]❌ CRITICAL: modrinth.index.json not found at root[/red]")
+                raise typer.Exit(1)
+
+            console.print("[green]✅ modrinth.index.json found[/green]")
+
+            # Read and validate index
+            index_data = json.loads(z.read("modrinth.index.json"))
+
+            # Check required fields
+            required = ["formatVersion", "game", "versionId", "name", "dependencies"]
+            for field in required:
+                if field not in index_data:
+                    issues.append(f"Missing required field: {field}")
+                    console.print(f"[red]❌ Missing: {field}[/red]")
+                else:
+                    value = index_data[field]
+                    if isinstance(value, dict):
+                        console.print(f"[green]✅ {field}[/green]")
+                    else:
+                        console.print(f"[green]✅ {field}: {value}[/green]")
+
+            # Check dependencies
+            deps = index_data.get("dependencies", {})
+            if "minecraft" not in deps:
+                issues.append("Missing minecraft in dependencies")
+                console.print("[red]❌ Missing: minecraft version[/red]")
+            else:
+                console.print(f"[green]✅ Minecraft: {deps['minecraft']}[/green]")
+
+            # Check for loader
+            loaders = ["fabric-loader", "quilt-loader", "forge", "neoforge"]
+            has_loader = any(l in deps for l in loaders)
+
+            if not has_loader:
+                issues.append("No mod loader in dependencies")
+                console.print("[red]❌ Missing mod loader[/red]")
+            else:
+                for loader in loaders:
+                    if loader in deps:
+                        console.print(f"[green]✅ Loader: {loader} = {deps[loader]}[/green]")
+
+            # Check files array
+            files_list = index_data.get("files", [])
+            console.print(f"\n[cyan]📦 Files registered: {len(files_list)}[/cyan]")
+
+            if len(files_list) == 0:
+                warnings.append("No files in array (pack might not work)")
+                console.print("[yellow]⚠️  WARNING: files array is empty[/yellow]")
+            else:
+                # Check first file structure
+                sample = files_list[0]
+                file_required = ["path", "hashes", "downloads", "fileSize"]
+
+                missing_fields = [f for f in file_required if f not in sample]
+                if missing_fields:
+                    issues.append(f"Files missing fields: {missing_fields}")
+                    console.print(f"[red]❌ Files missing: {', '.join(missing_fields)}[/red]")
+                else:
+                    console.print("[green]✅ File structure looks good[/green]")
+
+                # Check hashes
+                if "hashes" in sample:
+                    if "sha1" not in sample["hashes"]:
+                        issues.append("Files missing sha1 hash")
+                        console.print("[red]❌ Missing sha1 hashes[/red]")
+                    else:
+                        console.print("[green]✅ sha1 hashes present[/green]")
+
+                    if "sha512" not in sample["hashes"]:
+                        warnings.append("Files missing sha512 hash")
+                        console.print("[yellow]⚠️  Missing sha512 hashes (optional)[/yellow]")
+                    else:
+                        console.print("[green]✅ sha512 hashes present[/green]")
+
+                # Check env field
+                if "env" not in sample:
+                    warnings.append("Files missing env field")
+                    console.print("[yellow]⚠️  Missing env field (recommended)[/yellow]")
+                else:
+                    console.print("[green]✅ env field present[/green]")
+
+        # Summary
+        console.print("\n" + "=" * 60)
+
+        if issues:
+            console.print(f"\n[red bold]❌ CRITICAL ISSUES ({len(issues)}):[/red bold]")
+            for issue in issues:
+                console.print(f"  [red]• {issue}[/red]")
+
+        if warnings:
+            console.print(f"\n[yellow bold]⚠️  WARNINGS ({len(warnings)}):[/yellow bold]")
+            for warning in warnings:
+                console.print(f"  [yellow]• {warning}[/yellow]")
+
+        if not issues and not warnings:
+            console.print("\n[green bold]✅ All checks passed![/green bold]")
+            console.print("[dim]Pack should work in all Modrinth-compatible launchers[/dim]")
+        elif not issues:
+            console.print("\n[green]✅ No critical issues[/green]")
+            console.print("[dim]Pack should work, but consider addressing warnings[/dim]")
+        else:
+            console.print("\n[red bold]❌ Pack has critical issues[/red bold]")
+            console.print("[yellow]Run 'ModForge-CLI build' again to fix[/yellow]")
+            raise typer.Exit(1)
+
+    except zipfile.BadZipFile:
+        console.print("[red]❌ ERROR: Not a valid ZIP/MRPACK file[/red]")
+        raise typer.Exit(1)
+    except json.JSONDecodeError as e:
+        console.print("[red]❌ ERROR: Invalid JSON in modrinth.index.json[/red]")
+        console.print(f"[dim]{e}[/dim]")
+        raise typer.Exit(1)