packsmith 0.1.0__py3-none-any.whl

packsmith/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2026 Frank1o3
+# SPDX-License-Identifier: MIT

packsmith/__main__.py

@@ -0,0 +1,6 @@
+# Copyright (c) 2026 Frank1o3
+# SPDX-License-Identifier: MIT
+
+from .main import main
+
+main()

packsmith/api/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2026 Frank1o3
+# SPDX-License-Identifier: MIT
+from .modrinth import ModrinthClient
+
+__all__ = ["ModrinthClient"]

packsmith/api/modrinth.py

@@ -0,0 +1,140 @@
+# Copyright (c) 2026 Frank1o3
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import time
+from collections.abc import Mapping, Sequence
+from importlib.metadata import version
+from typing import TYPE_CHECKING, Any
+
+from httpx import AsyncClient, QueryParams, Response
+from pydantic import BaseModel
+
+from packsmith.core.models import Hit, ProjectVersion, ProjectVersions, Search
+
+if TYPE_CHECKING:
+    from packsmith.core.models import ProjectType
+
+PrimitiveData = str | int | float | bool | None
+
+QueryParamTypes = (
+    QueryParams
+    | Mapping[str, PrimitiveData | Sequence[PrimitiveData]]
+    | list[tuple[str, PrimitiveData]]
+    | tuple[tuple[str, PrimitiveData], ...]
+    | str
+    | bytes
+) | None
+
+logger = logging.getLogger(__name__)
+
+
+class RateLimitState(BaseModel):
+    limit: int | None = None
+    remaining: int | None = None
+    reset_after: float | None = None
+    last_update: float | None = None
+
+
+class ModrinthClient:
+    BASE_URL = "https://api.modrinth.com/v2"
+
+    def __init__(self) -> None:
+        user_agent = f"Frank1o3/packsmith/{version('packsmith')} (https://github.com/Frank1o3/packsmith)"
+
+        self._client = AsyncClient(
+            base_url=self.BASE_URL, headers={"User-Agent": user_agent}, timeout=30.0
+        )
+        self.rate = RateLimitState()
+        self._lock = asyncio.Lock()
+
+    async def get(
+        self,
+        path: str,
+        *,
+        params: QueryParamTypes = None,
+    ) -> Any:
+        async with self._lock:
+            await self._respect_rate_limit()
+
+        resp = await self._client.get(path, params=params)
+        self._update_rate_limit(resp)
+        resp.raise_for_status()
+
+        return resp.json()
+
+    async def search(
+        self, name: str, project_type: ProjectType, loader: str, game_version: str
+    ) -> Search:
+        facets = [
+            [f"project_type:{project_type}"],
+            [f"versions:{game_version}"],
+        ]
+        params = {
+            "query": name,
+            "limit": 15,
+            "facets": json.dumps(facets),
+        }
+        if project_type == "mod":
+            facets.append([f"categories:{loader}"])
+        return Search.model_validate(await self.get("/search", params=params))
+
+    async def get_project(self, project_id: str) -> Hit:
+        endpoint = f"/project/{project_id}/"
+        return Hit.model_validate_json(await self.get(endpoint))
+
+    async def get_project_versions(self, project_id: str) -> list[ProjectVersion]:
+        endpoint = f"/project/{project_id}/version"
+        return ProjectVersions.validate_python(await self.get(endpoint))
+
+    # ------------------------
+    # rate limit logic
+    # ------------------------
+    def _update_rate_limit(self, resp: Response) -> None:
+        headers = resp.headers
+
+        self.rate.limit = self._safe_int(headers.get("X-Ratelimit-Limit"))
+        self.rate.remaining = self._safe_int(headers.get("X-Ratelimit-Remaining"))
+
+        reset = headers.get("X-Ratelimit-Reset")
+        if reset is not None:
+            self.rate.reset_after = self._safe_float(reset)
+            self.rate.last_update = time.time()
+
+    async def _respect_rate_limit(self) -> None:
+        if (
+            self.rate.remaining is not None
+            and self.rate.remaining <= 0
+            and self.rate.reset_after is not None
+            and self.rate.last_update is not None
+        ):
+            wait_time = self.rate.reset_after - (time.time() - self.rate.last_update)
+            if wait_time > 0:
+                await asyncio.sleep(wait_time)
+
+    async def close(self) -> None:
+        await self._client.aclose()
+
+    async def __aexit__(self, *_: object) -> None:
+        await self.close()
+
+    # ------------------------
+    # Static methods
+    # ------------------------
+    @staticmethod
+    def _safe_int(value: str | None) -> int | None:
+        try:
+            return int(value) if value is not None else None
+        except ValueError:
+            return None
+
+    @staticmethod
+    def _safe_float(value: str | None) -> float | None:
+        try:
+            return float(value) if value is not None else None
+        except ValueError:
+            return None

packsmith/cli/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2026 Frank1o3
+# SPDX-License-Identifier: MIT

packsmith/cli/add.py

@@ -0,0 +1,160 @@
+# Copyright (c) 2026 Frank1o3
+# SPDX-License-Identifier: MIT
+
+import asyncio
+import tomllib
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import tomli_w
+import typer
+from rich.table import Table
+
+from packsmith.api import ModrinthClient
+from packsmith.cli.ui import console
+from packsmith.core.models import (
+    ERROR_NOT_IN_PACK,
+    PROJECT_TYPE_TO_FIELD,
+    Hit,
+    LockFile,
+    LockPackage,
+    Manifest,
+    MatchResults,
+    MatchScore,
+    ProjectType,
+    Search,
+)
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+
+async def search(
+    name: str, project_type: ProjectType, loader: str, game_version: str
+) -> Search:
+    client = ModrinthClient()
+    return await client.search(name, project_type, loader, game_version)
+
+
+def load_lock(path: Path) -> LockFile:
+    if path.stat().st_size == 0:
+        return LockFile()
+
+    with path.open("rb") as f:
+        data = tomllib.load(f)
+
+    return LockFile.model_validate(data)
+
+
+def save_lock(path: Path, lock: LockFile) -> None:
+    with path.open("wb") as f:
+        tomli_w.dump(lock.model_dump(exclude_none=True), f)
+
+
+def save_manifest(path: Path, manifest: Manifest) -> None:
+    path.write_text(manifest.model_dump_json(indent=2), encoding="utf-8")
+
+
+def has_package(lock: LockFile, project_id: str) -> bool:
+    return any(pkg.project_id == project_id for pkg in lock.packages)
+
+
+def select_match(matched: MatchResults, console: Console) -> Hit:
+    if not matched.results:
+        console.print("[red]No matches found.[/red]")
+        raise typer.Exit(code=1)
+
+    table = Table(title="Select a mod", show_lines=False)
+    table.add_column("#", style="dim", width=4)
+    table.add_column("Name", style="cyan")
+    table.add_column("Slug", style="dim")
+    table.add_column("Confidence", justify="right")
+
+    for i, result in enumerate(matched.results, start=1):
+        hit = result.hit
+        score = result.score
+
+        if score >= MatchScore.ACRONYM:
+            style = "green"
+        elif score >= MatchScore.PREFIX:
+            style = "yellow"
+        else:
+            style = "red"
+
+        table.add_row(str(i), hit.title, hit.slug, f"[{style}]{score}[/]")
+
+    console.print(table)
+
+    choice = typer.prompt("Select a mod by number", type=int)
+
+    if choice < 1 or choice > len(matched.results):
+        console.print("[red]Invalid selection.[/red]")
+        raise typer.Exit(code=1)
+
+    return matched.results[choice - 1].hit
+
+
+def apply_add(
+    info: Manifest,
+    lock: LockFile,
+    hit: Hit,
+) -> None:
+    field_name = PROJECT_TYPE_TO_FIELD.get(hit.project_type)
+
+    if field_name is None:
+        err = f"Unsupported project type: {hit.project_type}"
+        raise ValueError(err)
+
+    target_list: list[str] = getattr(info, field_name)
+
+    if hit.title not in target_list:
+        target_list.append(hit.title)
+
+    if not has_package(lock, hit.project_id):
+        lock.packages.append(
+            LockPackage(
+                project_id=hit.project_id,
+                project_type=hit.project_type,
+                client_side=hit.client_side,
+                server_side=hit.server_side,
+            )
+        )
+
+
+def resolve_hit(matched: MatchResults, console: Console) -> Hit | None:
+    if not matched.results:
+        console.print("[red]No matches found.[/red]")
+        raise typer.Exit(code=1)
+
+    if matched.best and matched.best.score == MatchScore.EXACT:
+        return matched.best.hit
+
+    return select_match(matched, console)
+
+
+def add(name: str, project_type: ProjectType) -> None:
+    path = Path.cwd()
+    register_file = path / "meta.json"
+    lock_file = path / "lock.toml"
+
+    if not register_file.exists() or not lock_file.exists():
+        raise RuntimeError(ERROR_NOT_IN_PACK)
+
+    info = Manifest.model_validate_json(register_file.read_text("utf-8"))
+    lock = load_lock(lock_file)
+
+    search_res = asyncio.run(search(name, project_type, info.loader, info.game_version))
+    matched = search_res.match(name, project_type)
+
+    hit = resolve_hit(matched, console)
+
+    if hit is None:
+        raise typer.Exit
+
+    apply_add(info, lock, hit)
+
+    save_manifest(register_file, info)
+    save_lock(lock_file, lock)
+    console.log(
+        f"[green]Added[/green] {hit.title} ({hit.project_type}) to the modpack."
+    )

packsmith/cli/downloader.py

@@ -0,0 +1,229 @@
+# Copyright (c) 2026 Frank1o3
+# SPDX-License-Identifier: MIT
+
+import asyncio
+import hashlib
+import hmac
+import tomllib
+from importlib.metadata import version
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+import httpx
+import typer
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
+
+from packsmith.cli.ui import console
+from packsmith.core.models import Hashes, LockFile, LockPackage
+
+user_agent = (
+    f"Frank1o3/packsmith/{version('packsmith')} (https://github.com/Frank1o3/packsmith)"
+)
+
+
+def load_lock(path: Path) -> LockFile:
+    if path.stat().st_size == 0:
+        return LockFile()
+
+    with path.open("rb") as f:
+        data = tomllib.load(f)
+
+    return LockFile.model_validate(data)
+
+
+def _get_filename_from_url(url: str, *, fallback: str | None = None) -> str:
+    if fallback:
+        return fallback
+
+    name = Path(unquote(urlparse(url).path)).name
+    if not name:
+        name = unquote(url.rsplit("/", maxsplit=1)[-1])
+    return name or "downloaded.file"
+
+
+def _get_package_dir(
+    package: LockPackage,
+    mods_dir: Path,
+    resourcepacks_dir: Path,
+    shaders_dir: Path,
+) -> Path:
+    if package.project_type == "resourcepack":
+        return resourcepacks_dir
+    if package.project_type == "shader":
+        return shaders_dir
+    return mods_dir
+
+
+def _validate_hashes(data: bytes, hashes: Hashes) -> bool:
+    if hashes.sha512:
+        actual_sha512 = hashlib.sha512(data).hexdigest()
+        if not hmac.compare_digest(actual_sha512, hashes.sha512):
+            return False
+
+    if hashes.sha1:
+        actual_sha1 = hashlib.new("sha1", data).hexdigest()
+        if not hmac.compare_digest(actual_sha1, hashes.sha1):
+            return False
+
+    return True
+
+
+async def _ensure_dir(path: Path) -> None:
+    await asyncio.to_thread(path.mkdir, parents=True, exist_ok=True)
+
+
+async def _read_file_bytes(path: Path) -> bytes:
+    return await asyncio.to_thread(path.read_bytes)
+
+
+async def _write_file_bytes(path: Path, data: bytes) -> None:
+    await asyncio.to_thread(path.write_bytes, data)
+
+
+async def _download_package(
+    client: httpx.AsyncClient,
+    package: LockPackage,
+    target_dir: Path,
+    progress: Progress,
+    semaphore: asyncio.Semaphore,
+) -> tuple[LockPackage, Path, str | None]:
+    if package.file is None:
+        message = f"Package {package.project_id} has no download file."
+        raise RuntimeError(message)
+
+    file = package.file
+    filename = _get_filename_from_url(file.url, fallback=file.filename)
+    target_path = target_dir / filename
+    await _ensure_dir(target_dir)
+
+    if target_path.exists():
+        existing_data = await _read_file_bytes(target_path)
+        if _validate_hashes(existing_data, file.hashes):
+            return package, target_path, "already downloaded"
+
+    task_id = progress.add_task(
+        "download",
+        filename=filename,
+        total=file.size or 0,
+    )
+
+    async with semaphore, client.stream("GET", file.url) as response:
+        response.raise_for_status()
+        total = int(response.headers.get("Content-Length", file.size or 0))
+        progress.update(task_id, total=total)
+        data = bytearray()
+
+        async for chunk in response.aiter_bytes(65536):
+            if not chunk:
+                continue
+            data.extend(chunk)
+            progress.update(task_id, advance=len(chunk))
+
+    final_data = bytes(data)
+    await _write_file_bytes(target_path, final_data)
+    progress.update(task_id, completed=total)
+
+    if not _validate_hashes(final_data, file.hashes):
+        target_path.unlink(missing_ok=True)
+        message = f"Hash mismatch for {package.project_id} ({filename})."
+        raise RuntimeError(message)
+
+    return package, target_path, None
+
+
+async def _download_all(
+    lock: LockFile,
+    mods_dir: Path,
+    resourcepacks_dir: Path,
+    shaders_dir: Path,
+) -> None:
+    packages = [
+        pkg for pkg in lock.packages if pkg.state == "resolved" and pkg.file is not None
+    ]
+    if not packages:
+        console.print(
+            "[yellow]No resolved packages with download files found.[/yellow]"
+        )
+        return
+
+    timeout = httpx.Timeout(60.0, connect=15.0)
+    semaphore = asyncio.Semaphore(5)
+    async with httpx.AsyncClient(
+        headers={"User-Agent": user_agent}, timeout=timeout
+    ) as client:
+        with Progress(
+            TextColumn("{task.fields[filename]}", justify="left"),
+            BarColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            TimeRemainingColumn(),
+            console=console,
+            transient=True,
+        ) as progress:
+            tasks = []
+            for package in packages:
+                target_dir = _get_package_dir(
+                    package, mods_dir, resourcepacks_dir, shaders_dir
+                )
+                tasks.append(
+                    _download_package(client, package, target_dir, progress, semaphore)
+                )
+
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    failures = 0
+    for result in results:
+        if isinstance(result, BaseException):
+            failures += 1
+            console.print(f"[red]Download failed:[/red] {result}")
+            continue
+
+        package, path, message = result
+        if message:
+            console.print(f"[cyan]Skipped existing file:[/cyan] {path.name}")
+        else:
+            console.print(f"[green]Downloaded:[/green] {path.name}")
+
+    if failures:
+        message = f"{failures} file(s) failed to download."
+        raise RuntimeError(message)
+
+
+def download() -> None:
+    """Download all dependencies for the current modpack.
+
+    Raises:
+        Exit: If the download fails or the project is invalid.
+
+    """
+    path = Path.cwd()
+    register_file = path / "meta.json"
+    lock_file = path / "lock.toml"
+    mods_dir = path / "mods"
+    resourcepacks_dir = path / "overrides" / "resourcepacks"
+    shaders_dir = path / "overrides" / "shaderpacks"
+
+    if not register_file.exists():
+        console.print(
+            "[red]Error:[/red] Not inside a Packsmith project (meta.json not found)."
+        )
+        raise typer.Exit(code=1)
+
+    if not lock_file.exists():
+        console.print("[red]Error:[/red] Missing lock file.")
+        raise typer.Exit(code=1)
+
+    lock = load_lock(lock_file)
+
+    try:
+        asyncio.run(_download_all(lock, mods_dir, resourcepacks_dir, shaders_dir))
+    except Exception as exc:
+        console.print(f"[red]Download failed:[/red] {exc}")
+        raise typer.Exit(code=1) from exc