modforge-cli 0.2.3__py3-none-any.whl

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/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]")

modforge_cli/cli/setup.py

@@ -0,0 +1,72 @@
+"""
+Setup command - Initialize a new modpack project
+"""
+
+import json
+from pathlib import Path
+
+import typer
+
+from modforge_cli.cli.shared import FABRIC_LOADER_VERSION, REGISTRY_PATH, console
+from modforge_cli.core import Manifest, load_registry, save_registry_atomic
+
+app = typer.Typer()
+
+
+@app.command()
+def setup(
+    name: str,
+    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
+
+    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
+    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,
+        "files": [],
+        "dependencies": {loader_key: loader_version, "minecraft": mc},
+    }
+    (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]")

modforge_cli/cli/shared.py

@@ -0,0 +1,41 @@
+"""
+Shared utilities and constants for CLI commands.
+"""
+
+from pathlib import Path
+
+from rich.console import Console
+
+# Shared console instance
+console = Console()
+
+# Configuration paths
+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"
+
+# Constants
+FABRIC_LOADER_VERSION = "0.16.9"
+
+# URLs
+GITHUB_RAW = "https://raw.githubusercontent.com/Frank1o3/ModForge-CLI"
+VERSION_TAG = "v0.1.8"
+
+FABRIC_INSTALLER_URL = (
+    "https://maven.fabricmc.net/net/fabricmc/fabric-installer/1.1.1/fabric-installer-1.1.1.jar"
+)
+FABRIC_INSTALLER_SHA256 = "8fa465768bd7fc452e08c3a1e5c8a6b4b5f6a4e64bc7def47f89d8d3a6f4e7b8"
+
+DEFAULT_MODRINTH_API_URL = f"{GITHUB_RAW}/{VERSION_TAG}/configs/modrinth_api.json"
+DEFAULT_POLICY_URL = f"{GITHUB_RAW}/{VERSION_TAG}/configs/policy.json"
+
+
+def get_version_info() -> tuple[str, str]:
+    """Get version and author info"""
+    try:
+        from modforge_cli.__version__ import __author__, __version__
+
+        return __version__, __author__
+    except ImportError:
+        return "unknown", "Frank1o3"

modforge_cli/cli/sklauncher.py

@@ -0,0 +1,125 @@
+"""
+SKLauncher integration command
+"""
+
+from datetime import datetime
+import json
+from pathlib import Path
+import platform
+import shutil
+
+import typer
+
+from modforge_cli.cli.shared import FABRIC_LOADER_VERSION, REGISTRY_PATH, console
+from modforge_cli.core import get_manifest, load_registry
+
+app = typer.Typer()
+
+
+@app.command()
+def sklauncher(pack_name: str | None = None, profile_name: str | None = None) -> None:
+    """Create SKLauncher-compatible profile (alternative to export)"""
+
+    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)
+
+    # Check if mods are built
+    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)
+
+    # Get Minecraft directory
+    if platform.system() == "Windows":
+        minecraft_dir = Path.home() / "AppData" / "Roaming" / ".minecraft"
+    elif platform.system() == "Darwin":
+        minecraft_dir = Path.home() / "Library" / "Application Support" / "minecraft"
+    else:
+        minecraft_dir = Path.home() / ".minecraft"
+
+    if not minecraft_dir.exists():
+        console.print(f"[red]Minecraft directory not found: {minecraft_dir}[/red]")
+        raise typer.Exit(1)
+
+    # Use pack name if profile name not specified
+    if not profile_name:
+        profile_name = pack_name
+
+    console.print(f"[cyan]Creating SKLauncher profile '{profile_name}'...[/cyan]")
+
+    # Create instance directory
+    instance_dir = minecraft_dir / "instances" / profile_name
+    instance_dir.mkdir(parents=True, exist_ok=True)
+
+    # Copy mods
+    dst_mods = instance_dir / "mods"
+    if dst_mods.exists():
+        shutil.rmtree(dst_mods)
+    shutil.copytree(mods_dir, dst_mods)
+    mod_count = len(list(dst_mods.glob("*.jar")))
+    console.print(f"[green]✓ Copied {mod_count} mods[/green]")
+
+    # Copy overrides
+    overrides_src = pack_path / "overrides"
+    if overrides_src.exists():
+        for item in overrides_src.iterdir():
+            dst = instance_dir / item.name
+            if item.is_dir():
+                if dst.exists():
+                    shutil.rmtree(dst)
+                shutil.copytree(item, dst)
+            else:
+                shutil.copy2(item, dst)
+        console.print("[green]✓ Copied overrides[/green]")
+
+    # Update launcher_profiles.json
+    profiles_file = minecraft_dir / "launcher_profiles.json"
+
+    if profiles_file.exists():
+        profiles_data = json.loads(profiles_file.read_text())
+    else:
+        profiles_data = {"profiles": {}, "settings": {}, "version": 3}
+
+    # Create profile entry
+    profile_id = profile_name.lower().replace(" ", "_").replace("-", "_")
+    loader_version = manifest.loader_version or FABRIC_LOADER_VERSION
+
+    profiles_data["profiles"][profile_id] = {
+        "name": profile_name,
+        "type": "custom",
+        "created": datetime.now().isoformat() + "Z",
+        "lastUsed": datetime.now().isoformat() + "Z",
+        "icon": "Furnace_On",
+        "lastVersionId": f"fabric-loader-{loader_version}-{manifest.minecraft}",
+        "gameDir": str(instance_dir),
+    }
+
+    # Save profiles
+    profiles_file.write_text(json.dumps(profiles_data, indent=2))
+
+    console.print("\n[green bold]✓ SKLauncher profile created![/green bold]")
+    console.print(f"\n[cyan]Profile:[/cyan] {profile_name}")
+    console.print(f"[cyan]Location:[/cyan] {instance_dir}")
+    console.print(f"[cyan]Version:[/cyan] fabric-loader-{loader_version}-{manifest.minecraft}")
+    console.print("\n[yellow]Next steps:[/yellow]")
+    console.print("  1. Close SKLauncher if it's open")
+    console.print("  2. Restart SKLauncher")
+    console.print(f"  3. Select profile '{profile_name}'")
+    console.print("  4. If Fabric isn't installed, install it from SKLauncher:")
+    console.print(f"     - MC: {manifest.minecraft}")
+    console.print(f"     - Fabric: {loader_version}")

modforge_cli/cli/utils.py

@@ -0,0 +1,64 @@
+"""
+Utility commands - Doctor and self-update
+"""
+
+import subprocess
+import sys
+
+import typer
+
+from modforge_cli.cli.shared import MODRINTH_API, POLICY_PATH, REGISTRY_PATH, console
+from modforge_cli.core import load_registry, self_update as core_self_update
+
+app = typer.Typer()
+
+
+@app.command()
+def doctor() -> None:
+    """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}"
+    console.print(f"[green]✓[/green] Python {py_version}")
+
+    # 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:
+        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() -> None:
+    """Update ModForge-CLI to latest version"""
+    try:
+        core_self_update(console)
+    except Exception as e:
+        console.print(f"[red]Update failed:[/red] {e}")
+        raise typer.Exit(1) from e

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",
+]