modforge-cli 0.2.2__tar.gz → 0.2.3__tar.gz

{modforge_cli-0.2.2 → modforge_cli-0.2.3}/PKG-INFO

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

{modforge_cli-0.2.2 → modforge_cli-0.2.3}/pyproject.toml

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

modforge_cli-0.2.3/src/modforge_cli/__init__.py

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

modforge_cli-0.2.3/src/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-0.2.2 → modforge_cli-0.2.3}/src/modforge_cli/__version__.py

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

modforge_cli-0.2.3/src/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-0.2.3/src/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)

modforge_cli-0.2.3/src/modforge_cli/cli/modpack.py

@@ -0,0 +1,150 @@
+"""
+Modpack operations - Add, resolve, build
+"""
+
+import asyncio
+from pathlib import Path
+
+import typer
+
+from modforge_cli.api import ModrinthAPIConfig
+from modforge_cli.cli.shared import MODRINTH_API, POLICY_PATH, REGISTRY_PATH, console
+from modforge_cli.core import (
+    ModPolicy,
+    ModResolver,
+    get_api_session,
+    get_manifest,
+    load_registry,
+    perform_add,
+    run,
+)
+
+app = typer.Typer()
+
+# Initialize API
+api = ModrinthAPIConfig(MODRINTH_API)
+
+
+@app.command()
+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"]:
+        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:
+            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: str | None = None) -> 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("[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) from e
+
+    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: str | None = None) -> 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) from e

modforge_cli-0.2.3/src/modforge_cli/cli/project.py

@@ -0,0 +1,72 @@
+"""
+Project management commands - List and remove projects
+"""
+
+from pathlib import Path
+import shutil
+
+from rich.panel import Panel
+from rich.prompt import Confirm
+from rich.table import Table
+import typer
+
+from modforge_cli.cli.shared import REGISTRY_PATH, console
+from modforge_cli.core import load_registry, save_registry_atomic
+
+app = typer.Typer()
+
+
+@app.command(name="ls")
+def list_projects() -> None:
+    """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 remove(pack_name: str) -> None:
+    """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]")