modforge-cli 0.2.7__tar.gz → 0.2.9__tar.gz

{modforge_cli-0.2.7 → modforge_cli-0.2.9}/PKG-INFO

@@ -1,18 +1,14 @@
 Metadata-Version: 2.4
 Name: modforge-cli
-Version: 0.2.7
+Version: 0.2.9
 Summary: ModForge-CLI — a Modrinth-based Minecraft modpack builder
 License: MIT
 License-File: LICENSE
 Author: Frank1o3
 Author-email: jahdy1o3@gmail.com
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.13,<3.15
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

{modforge_cli-0.2.7 → modforge_cli-0.2.9}/pyproject.toml

@@ -1,11 +1,10 @@
 [project]
 name = "modforge-cli"
-version = "0.2.7"
+version = "0.2.9"
 description = "ModForge-CLI — a Modrinth-based Minecraft modpack builder"
-authors = [{ name = "Frank1o3", email = "jahdy1o3@gmail.com" }]
-license = { text = "MIT" }
 readme = "README.md"
-requires-python = ">=3.10,<4.0"
+requires-python = ">=3.13,<3.15"
+
 dependencies = [
     "requests (>=2.32.5,<3.0.0)",
     "jsonschema (>=4.25.1,<5.0.0)",
@@ -17,31 +16,37 @@ dependencies = [
     "pyfiglet (>=1.0.4,<2.0.0)",
     "typer (>=0.21.1,<0.22.0)",
 ]
+
 classifiers = [
     "Development Status :: 4 - Beta",
     "Environment :: Console",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Topic :: Software Development :: Build Tools",
 ]
 
+[[project.authors]]
+name = "Frank1o3"
+email = "jahdy1o3@gmail.com"
+
+[project.license]
+text = "MIT"
+
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]
 build-backend = "poetry.core.masonry.api"
 
 [dependency-groups]
 dev = [
+    "ruff (>=0.14.8,<0.15.0)",
+    "mypy (>=1.19.0,<2.0.0)",
+]
+types = [
     "types-requests (>=2.32.4.20250913,<3.0.0.0)",
     "types-jsonschema (>=4.25.1.20251009,<5.0.0.0)",
     "types-tqdm (>=4.67.0.20250809,<5.0.0.0)",
-    "ruff (>=0.14.8,<0.15.0)",
-    "mypy (>=1.19.0,<2.0.0)",
-    "types-colorama (>=0.4.15.20250801,<0.5.0.0)",
+    "types-colorama (>=0.4.15.20250801,<0.5.0.0)"
 ]
 
 [tool.poetry]

{modforge_cli-0.2.7 → modforge_cli-0.2.9}/src/modforge_cli/__init__.py

@@ -1,3 +1,3 @@
 """
 CLI package for ModForge-CLI
-"""
+"""

{modforge_cli-0.2.7 → modforge_cli-0.2.9}/src/modforge_cli/__main__.py

@@ -103,9 +103,10 @@ def register_commands() -> None:
     Delayed import prevents import-time crashes.
     """
 
-    from modforge_cli.cli import export, modpack, project, setup, sklauncher
+    from modforge_cli.cli import export, modpack, mods, project, setup, sklauncher
 
     app.command()(setup.setup)
+    app.add_typer(mods.app, name="mods", help="Mod management commands")
     app.add_typer(project.app, name="project", help="Project management commands")
     app.command("ls")(project.list_projects)
     app.command()(project.remove)
@@ -132,4 +133,4 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    main()
+    main()

{modforge_cli-0.2.7 → modforge_cli-0.2.9}/src/modforge_cli/__version__.py

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

{modforge_cli-0.2.7 → modforge_cli-0.2.9}/src/modforge_cli/api/modrinth.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 from urllib.parse import quote_plus
 
 
@@ -16,14 +16,14 @@ class ModrinthAPIConfig:
     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.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:
+        with open(self.config_path, encoding="utf-8") as f:
             data = json.load(f)
 
         self.base_url = data.get("BASE_URL", "").rstrip("/")
@@ -31,7 +31,7 @@ class ModrinthAPIConfig:
             raise ValueError("BASE_URL missing in modrinth_api.json")
 
         self.endpoints = data.get("ENDPOINTS", {})
-        if not isinstance(self.endpoints, Dict):
+        if not isinstance(self.endpoints, dict):
             raise ValueError("ENDPOINTS section is invalid")
 
     def build_url(self, template: str, **kwargs: str) -> str:
@@ -46,16 +46,16 @@ class ModrinthAPIConfig:
 
     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",
+        query: str | None = None,
+        facets: list[list[str]] | str | None = None,
+        categories: list[str] | None = None,
+        loaders: list[str] | None = None,
+        game_versions: list[str] | None = None,
+        license_: str | None = None,
+        project_type: str | None = None,
+        offset: int | None = None,
+        limit: int | None = 10,
+        index: str | None = "relevance",
     ) -> str:
         """
         Build the Modrinth search URL with query parameters.

modforge_cli-0.2.9/src/modforge_cli/cli/__init__.py

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

{modforge_cli-0.2.7 → modforge_cli-0.2.9}/src/modforge_cli/cli/modpack.py

@@ -61,7 +61,14 @@ def add(name: str, project_type: str = "mod", pack_name: str | None = None) -> N
 
 
 @app.command()
-def resolve(pack_name: str | None = None) -> None:
+def resolve(
+    pack_name: str | None = None,
+    include_optional: bool = typer.Option(
+        False,
+        "--include-optional",
+        help="Include optional dependencies (e.g., ViaFabric multi-version sub-mods)",
+    ),
+) -> None:
     """Resolve all mod dependencies"""
     api = ModrinthAPIConfig(MODRINTH_API)
 
@@ -87,14 +94,22 @@ def resolve(pack_name: str | None = None) -> None:
         console.print("[red]Could not load manifest[/red]")
         raise typer.Exit(1)
 
-    console.print(f"[cyan]Resolving dependencies for {pack_name}...[/cyan]")
+    if include_optional:
+        console.print(f"[cyan]Resolving dependencies for {pack_name} (including optional)...[/cyan]")
+    else:
+        console.print(f"[cyan]Resolving dependencies for {pack_name} (required only)...[/cyan]")
+        console.print("[dim]Tip: Use --include-optional to add optional dependencies[/dim]")
 
     policy = ModPolicy(POLICY_PATH)
     resolver = ModResolver(
-        policy=policy, api=api, mc_version=manifest.minecraft, loader=manifest.loader
+        policy=policy,
+        api=api,
+        mc_version=manifest.minecraft,
+        loader=manifest.loader,
+        include_optional_deps=include_optional,
     )
 
-    async def do_resolve():
+    async def do_resolve() -> set[str]:
         async with await get_api_session() as session:
             return await resolver.resolve(manifest.mods, session)
 
@@ -104,7 +119,7 @@ def resolve(pack_name: str | None = None) -> None:
         console.print(f"[red]Resolution failed:[/red] {e}")
         raise typer.Exit(1) from e
 
-    manifest.mods = sorted(list(resolved_mods))
+    manifest.mods = sorted(resolved_mods)
     manifest_file.write_text(manifest.model_dump_json(indent=4))
 
     console.print(f"[green]✓ Resolved {len(manifest.mods)} mods[/green]")

modforge_cli-0.2.9/src/modforge_cli/cli/mods.py

@@ -0,0 +1,161 @@
+"""
+Mod management command - List, inspect, and verify mods in a modpack
+"""
+
+import asyncio
+from pathlib import Path
+
+import aiohttp
+from rich.table import Table
+import typer
+
+from modforge_cli.api import ModrinthAPIConfig
+from modforge_cli.cli.shared import MODRINTH_API, REGISTRY_PATH, console
+from modforge_cli.core import get_api_session, get_manifest, load_registry
+
+app = typer.Typer()
+
+
+@app.command("list")
+def list_mods(pack_name: str | None = None, resolved: bool = False) -> None:
+    """
+    List all mods in the current modpack.
+
+    Shows mod names, slugs, and project IDs from the manifest.
+    Use --resolved to also fetch and display actual mod names from Modrinth.
+
+    Examples:
+        ModForge-CLI mods list                  # Show manifest entries
+        ModForge-CLI mods list --resolved       # Fetch and show actual mod names
+        ModForge-CLI mods list --pack-name MyPack
+    """
+    # Auto-detect pack if not specified
+    if not pack_name:
+        manifest = get_manifest(console, path=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 = get_manifest(console, pack_path)
+    if not manifest:
+        console.print(f"[red]Could not load manifest for '{pack_name}'[/red]")
+        raise typer.Exit(1)
+
+    if not manifest.mods:
+        console.print("[yellow]No mods in this modpack[/yellow]")
+        return
+
+    if resolved:
+        # Fetch actual mod names from Modrinth
+        asyncio.run(_fetch_and_display_mod_info(manifest.mods))
+    else:
+        # Just show what's in the manifest
+        _show_manifest_mods(manifest.mods, manifest.name)
+
+
+def _show_manifest_mods(mods: list[str], pack_name: str) -> None:
+    """Display mods from manifest without API calls"""
+    console.print(f"\n[cyan bold]Mods in '{pack_name}' (from manifest):[/cyan bold]\n")
+
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("#", style="dim", width=4)
+    table.add_column("Slug / ID", style="green")
+    table.add_column("Type", style="dim")
+
+    for idx, mod in enumerate(sorted(mods), 1):
+        # Heuristic: project IDs are typically numeric-like strings (e.g., "AANobbMI")
+        # Slugs are typically lowercase with dashes
+        if any(c.isupper() for c in mod) or len(mod) < 5:
+            mod_type = "Project ID"
+        else:
+            mod_type = "Slug"
+        table.add_row(str(idx), mod, mod_type)
+
+    console.print(table)
+    console.print(f"\n[dim]Total: {len(mods)} mod(s)[/dim]")
+    console.print("[yellow]Tip: Use 'ModForge-CLI mods list --resolved' to fetch actual names[/yellow]\n")
+
+
+async def _fetch_and_display_mod_info(mod_entries: list[str]) -> None:
+    """Fetch mod info from Modrinth API and display"""
+    api = ModrinthAPIConfig(MODRINTH_API)
+
+    console.print("\n[cyan bold]Fetching mod information from Modrinth...[/cyan bold]\n")
+
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("#", style="dim", width=4)
+    table.add_column("Name", style="green")
+    table.add_column("Slug", style="cyan")
+    table.add_column("Project ID", style="dim")
+    table.add_column("Summary", style="yellow")
+
+    async with await get_api_session() as session:
+        tasks = [_fetch_mod_info(api, entry, session) for entry in sorted(mod_entries)]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    success_count = 0
+    for idx, result in enumerate(results, 1):
+        if isinstance(result, BaseException):
+            table.add_row(str(idx), "[red]Error[/red]", "[red]Error[/red]", "[red]Error[/red]", "")
+            continue
+
+        if result is None:
+            table.add_row(str(idx), "[yellow]Not found[/yellow]", "[yellow]N/A[/yellow]", "[yellow]N/A[/yellow]", "")
+            continue
+
+        success_count += 1
+        name, slug, project_id, summary = result
+        # Truncate summary if too long
+        if summary and len(summary) > 60:
+            summary = summary[:57] + "..."
+        table.add_row(str(idx), name, slug, project_id, summary or "")
+
+    console.print(table)
+    console.print(f"\n[dim]Resolved: {success_count}/{len(mod_entries)} mod(s)[/dim]\n")
+
+
+async def _fetch_mod_info(
+    api: ModrinthAPIConfig, entry: str, session: aiohttp.ClientSession
+) -> tuple[str, str, str, str] | None:
+    """
+    Fetch mod information from Modrinth API.
+
+    Args:
+        entry: Can be either a slug or project ID
+        session: Active aiohttp session
+
+    Returns:
+        Tuple of (name, slug, project_id, summary) or None on failure
+    """
+    url = api.project(entry)
+
+    try:
+        async with session.get(url) as response:
+            if response.status != 200:
+                console.print(f"[dim]  Warning: Failed to fetch '{entry}' (HTTP {response.status})[/dim]")
+                return None
+
+            data = await response.json()
+
+            name = data.get("title", entry)
+            slug = data.get("slug", entry)
+            project_id = data.get("id", entry)
+            summary = data.get("description", "")
+
+            return (name, slug, project_id, summary)
+
+    except Exception as e:
+        console.print(f"[dim]  Error fetching '{entry}': {e}[/dim]")
+        return None

{modforge_cli-0.2.7 → modforge_cli-0.2.9}/src/modforge_cli/core/downloader.py

@@ -5,7 +5,7 @@ from collections.abc import Iterable
 import hashlib
 import json
 from pathlib import Path
-from pprint import pprint
+from typing import Any
 
 import aiohttp
 from rich.console import Console
@@ -54,43 +54,40 @@ class ModDownloader:
         if "files" not in self.index:
             self.index["files"] = []
 
-    def _select_compatible_version(self, versions: list[dict]) -> dict | None:
+    def _select_compatible_version(self, versions: list[Any]) -> Any | None:
         """
-        Select the most appropriate version based on:
-        1. Loader compatibility (fabric/forge/quilt/neoforge)
-        2. Minecraft version
-        3. Version type (prefer release > beta > alpha)
+        Select the best version for the target MC version and loader.
+
+        Priority:
+        1. Release versions matching MC + loader (newest first)
+        2. Any version matching MC + loader (newest first)
+
+        This matches the resolver's _select_version logic for consistency.
         """
-        # Normalize loader name for comparison
         loader_lower = self.loader.lower()
+        version_priority = {"release": 3, "beta": 2, "alpha": 1}
 
-        # Filter versions that match both MC version and loader
+        def version_score(v: Any) -> tuple[int, str]:
+            vtype = version_priority.get(v.get("version_type", "alpha"), 0)
+            # Use date_published for chronological ordering (ISO 8601, sortable)
+            vdate = v.get("date_published", "") or ""
+            return (vtype, str(vdate))
+
+        # Filter compatible versions
         compatible = []
         for v in versions:
-            # Check if MC version matches
             if self.mc_version not in v.get("game_versions", []):
                 continue
-
-            # Check if loader matches (case-insensitive)
-            loaders = [l.lower() for l in v.get("loaders", [])]
+            loaders = [loader.lower() for loader in v.get("loaders", [])]
             if loader_lower not in loaders:
                 continue
-
             compatible.append(v)
 
         if not compatible:
             return None
 
-        # Prioritize by version type: release > beta > alpha
-        version_priority = {"release": 3, "beta": 2, "alpha": 1}
-
-        def version_score(v) -> int:
-            vtype = v.get("version_type", "alpha")
-            return version_priority.get(vtype, 0)
-
-        # Sort by version type, then by date (newest first)
-        compatible.sort(key=lambda v: (version_score(v), v.get("date_published", "")), reverse=True)
-
+        # Sort by version type (release > beta > alpha), then by ID (newest first)
+        compatible.sort(key=version_score, reverse=True)
         return compatible[0]
 
     async def download_all(self, project_ids: Iterable[str]) -> None:
@@ -122,7 +119,6 @@ class ModDownloader:
         # 1. Fetch all versions for this project
         project_url = self.api.project(project_id)
         url = self.api.project_versions(project_id)
-        self.api.environments()
 
         try:
             async with self.session.get(url) as r, self.session.get(project_url) as rs:

{modforge_cli-0.2.7 → modforge_cli-0.2.9}/src/modforge_cli/core/models.py

@@ -55,6 +55,7 @@ class ProjectVersion(BaseAPIModel):
     files: list[File] = Field(default_factory=list)
     game_versions: list[str] = Field(default_factory=list)
     loaders: list[str] = Field(default_factory=list)
+    date_published: str | None = None
 
     @property
     def is_release(self) -> bool:
@@ -63,4 +64,4 @@ class ProjectVersion(BaseAPIModel):
 
 ProjectVersionList = TypeAdapter(list[ProjectVersion])
 
-__all__ = ["Manifest", "SearchResult", "ProjectVersion", "ProjectVersionList"]
+__all__ = ["Manifest", "ProjectVersion", "ProjectVersionList", "SearchResult"]

{modforge_cli-0.2.7 → modforge_cli-0.2.9}/src/modforge_cli/core/resolver.py

@@ -1,12 +1,17 @@
 import asyncio
 from collections import deque
 from collections.abc import Iterable
+from typing import Any
 
 import aiohttp
+from rich.console import Console
 
 from modforge_cli.api import ModrinthAPIConfig
-from modforge_cli.core.models import ProjectVersion, ProjectVersionList, SearchResult
+from modforge_cli.core.models import Hit, ProjectVersion, ProjectVersionList, SearchResult
 from modforge_cli.core.policy import ModPolicy
+from modforge_cli.core.utils import calculate_match_score
+
+console = Console()
 
 try:
     from modforge_cli.__version__ import __author__, __version__
@@ -23,52 +28,97 @@ class ModResolver:
         api: ModrinthAPIConfig,
         mc_version: str,
         loader: str,
+        include_optional_deps: bool = False,
     ) -> None:
         self.policy = policy
         self.api = api
         self.mc_version = mc_version
         self.loader = loader
+        self.include_optional_deps = include_optional_deps
 
         self._headers = {"User-Agent": f"{__author__}/ModForge-CLI/{__version__}"}
 
     def _select_version(self, versions: list[ProjectVersion]) -> ProjectVersion | None:
         """
-        Prefer:
-        1. Release versions
-        2. Matching MC + loader
+        Select the best version for the target MC version and loader.
+
+        Priority:
+        1. Release versions matching MC + loader (newest first)
+        2. Any version matching MC + loader (newest first)
         """
-        for v in versions:
-            if v.is_release and self.mc_version in v.game_versions and self.loader in v.loaders:
-                return v
+        version_priority = {"release": 3, "beta": 2, "alpha": 1}
+
+        def version_score(v: ProjectVersion) -> tuple[int, str]:
+            vtype = version_priority.get(v.version_type, 0)
+            # Use date_published for chronological ordering (ISO 8601, sortable)
+            vdate = v.date_published or ""
+            return (vtype, vdate)
 
-        for v in versions:
-            if self.mc_version in v.game_versions and self.loader in v.loaders:
-                return v
+        # Filter compatible versions
+        compatible = [
+            v for v in versions
+            if self.mc_version in v.game_versions and self.loader in v.loaders
+        ]
 
-        return None
+        if not compatible:
+            return None
+
+        # Sort by version type (release > beta > alpha), then by date (newest first)
+        compatible.sort(key=version_score, reverse=True)
+        return compatible[0]
 
     async def _search_project(self, slug: str, session: aiohttp.ClientSession) -> str | None:
-        """Search for a project by slug and return its project_id"""
+        """
+        Search for a project by slug and return its project_id.
+
+        Uses fuzzy matching to find the best hit (same scoring as 'add' command).
+        Returns None if no suitable match is found.
+        """
         url = self.api.search(
             slug,
             game_versions=[self.mc_version],
             loaders=[self.loader],
+            project_type="mod",
         )
 
         try:
             async with session.get(url) as response:
                 data = SearchResult.model_validate_json(await response.text())
 
+            if not data.hits:
+                return None
+
+            # Find best matching hit using the same scoring as 'add' command
+            best_hit: Hit | None = None
+            best_score = 0
+
             for hit in data.hits:
                 if hit.project_type != "mod":
                     continue
                 if self.mc_version not in hit.versions:
                     continue
-                return hit.project_id
-        except Exception as e:
-            print(f"Warning: Failed to search for '{slug}': {e}")
 
-        return None
+                score = calculate_match_score(slug, hit.slug, getattr(hit, "title", ""))
+                if score > best_score:
+                    best_score = score
+                    best_hit = hit
+
+            # Only accept high-confidence matches (score >= 80)
+            if best_hit and best_score >= 80:
+                return best_hit.project_id
+
+            # Fallback: if exact slug match (score 100), accept regardless
+            for hit in data.hits:
+                if hit.project_type != "mod":
+                    continue
+                if hit.slug == slug:
+                    return hit.project_id
+
+            return None
+
+        except Exception as e:
+            console.print(f"[yellow]Warning: Failed to search for '{slug}': {e}[/yellow]")
+            return None
 
     async def _fetch_versions(
         self, project_id: str, session: aiohttp.ClientSession
@@ -80,7 +130,7 @@ class ModResolver:
             async with session.get(url) as response:
                 return ProjectVersionList.validate_json(await response.text())
         except Exception as e:
-            print(f"Warning: Failed to fetch versions for '{project_id}': {e}")
+            console.print(f"[yellow]Warning: Failed to fetch versions for '{project_id}': {e}[/yellow]")
             return []
 
     async def resolve(self, mods: Iterable[str], session: aiohttp.ClientSession) -> set[str]:
@@ -99,8 +149,9 @@ class ModResolver:
         resolved: set[str] = set()
         queue: deque[str] = deque()
 
-        search_cache: dict[str, str | None] = {}
+        search_cache: dict[str, Any] = {}
         version_cache: dict[str, list[ProjectVersion]] = {}
+        failed_slugs: list[str] = []
 
         # ---- Phase 1: slug → project_id (parallel) ----
         search_tasks = []
@@ -114,12 +165,15 @@ class ModResolver:
         if search_tasks:
             search_results = await asyncio.gather(*search_tasks, return_exceptions=True)
 
-            for slug, result in zip(slugs_to_search, search_results):
+            for slug, result in zip(slugs_to_search, search_results, strict=False):
                 if isinstance(result, Exception):
-                    print(f"Error searching for '{slug}': {result}")
+                    console.print(f"[red]Error searching for '{slug}': {result}[/red]")
+                    failed_slugs.append(slug)
+                elif result is None:
+                    failed_slugs.append(slug)
                     search_cache[slug] = None
                 else:
-                    search_cache[slug] = result
+                    search_cache[slug] = str(result)
 
         # Add found projects to queue
         for slug in expanded:
@@ -150,12 +204,12 @@ class ModResolver:
             if version_tasks:
                 version_results = await asyncio.gather(*version_tasks, return_exceptions=True)
 
-                for pid, result in zip(projects_to_fetch, version_results, strict=False):
-                    if isinstance(result, Exception):
-                        print(f"Error fetching versions for '{pid}': {result}")
+                for pid, ver_result in zip(projects_to_fetch, version_results, strict=False):
+                    if isinstance(ver_result, Exception):
+                        console.print(f"[red]Error fetching versions for '{pid}': {ver_result}[/red]")
                         version_cache[pid] = []
-                    else:
-                        version_cache[pid] = result
+                    elif isinstance(ver_result, list):
+                        version_cache[pid] = ver_result
 
             # Process dependencies
             for pid in batch:
@@ -163,7 +217,7 @@ class ModResolver:
                 version = self._select_version(versions)
 
                 if not version:
-                    print(f"Warning: No compatible version found for '{pid}'")
+                    console.print(f"[yellow]Warning: No compatible version found for '{pid}'[/yellow]")
                     continue
 
                 for dep in version.dependencies:
@@ -175,14 +229,25 @@ class ModResolver:
 
                     if dtype == "incompatible" and dep_id in resolved:
                         resolved.remove(dep_id)
-                        print(
-                            f"Warning: Removed incompatible dependency '{dep_id}' "
-                            f"(conflicts with '{pid}') — it may have been added earlier."
+                        console.print(
+                            f"[yellow]Warning: Removed incompatible dependency '{dep_id}' "
+                            f"(conflicts with '{pid}')[/yellow]"
                         )
 
-                    if dtype in ("required", "optional") and dep_id not in resolved:
+                    if dtype == "required" and dep_id not in resolved:
                         resolved.add(dep_id)
                         queue.append(dep_id)
+                    elif dtype == "optional" and self.include_optional_deps and dep_id not in resolved:
+                        resolved.add(dep_id)
+                        queue.append(dep_id)
+                        console.print(f"[dim]  + Optional dep added: {dep_id}[/dim]")
+
+        # Report failed slugs
+        if failed_slugs:
+            console.print(f"\n[yellow]Warning: {len(failed_slugs)} mod(s) could not be resolved:[/yellow]")
+            for slug in failed_slugs:
+                console.print(f"  - {slug}")
+            console.print("[dim]Check the slugs or try searching on https://modrinth.com[/dim]\n")
 
-        del queue, expanded, search_cache, version_cache
+        del queue, expanded, search_cache, version_cache, failed_slugs
         return resolved

{modforge_cli-0.2.7 → modforge_cli-0.2.9}/src/modforge_cli/core/utils.py

@@ -65,43 +65,43 @@ def calculate_match_score(search_term: str, hit_slug: str, hit_title: str = "")
     """
     search_lower = search_term.lower()
     search_normalized = normalize_search_term(search_term)
-    
+
     slug_lower = hit_slug.lower()
     slug_normalized = normalize_search_term(hit_slug)
-    
+
     title_lower = hit_title.lower() if hit_title else ""
     title_normalized = normalize_search_term(hit_title) if hit_title else ""
-    
+
     # Exact matches (highest priority)
     if search_term == hit_slug:
         return 100
     if search_lower == title_lower:
         return 90
-    
+
     # Normalized matches
     if search_normalized == slug_normalized:
         return 80
     if title_normalized and search_normalized == title_normalized:
         return 70
-    
+
     # Starts with matches
     if slug_lower.startswith(search_lower):
         return 60
     if title_lower and title_lower.startswith(search_lower):
         return 50
-    
+
     # Contains matches
     if search_lower in slug_lower:
         return 40
     if title_lower and search_lower in title_lower:
         return 30
-    
+
     # Normalized contains (fallback)
     if search_normalized in slug_normalized:
         return 20
     if title_normalized and search_normalized in title_normalized:
         return 10
-    
+
     return 0
 
 
@@ -114,16 +114,16 @@ def find_best_match(search_term: str, hits: list) -> tuple[object, int]:
     """
     best_hit = None
     best_score = 0
-    
+
     for hit in hits:
         # Get title from hit if available
         title = getattr(hit, 'title', '') or getattr(hit, 'name', '')
         score = calculate_match_score(search_term, hit.slug, title)
-        
+
         if score > best_score:
             best_score = score
             best_hit = hit
-    
+
     return best_hit, best_score
 
 
@@ -198,7 +198,7 @@ def load_registry(path: Path) -> dict[str, str]:
 
     try:
         return json.loads(path.read_text())
-    except json.JSONDecodeError as e:
+    except json.JSONDecodeError:
         # Registry is corrupted - back it up and start fresh
         backup = path.with_suffix(f".corrupt-{datetime.now():%Y%m%d-%H%M%S}.json")
         shutil.copy(path, backup)
@@ -223,7 +223,7 @@ def setup_crash_logging() -> Path:
             traceback.print_exception(exc_type, exc_value, exc_traceback, file=f)
 
         console = Console()
-        console.print(f"\n[red bold]ModForge-CLI crashed![/red bold]")
+        console.print("\n[red bold]ModForge-CLI crashed![/red bold]")
         console.print(f"[yellow]Crash log saved to:[/yellow] {log_file}")
         console.print("[dim]Please include this file when reporting the issue at:")
         console.print("[dim]https://github.com/Frank1o3/ModForge-CLI/issues\n")
@@ -354,13 +354,13 @@ async def perform_add(
 
         # Find best match using scoring system
         best_hit, best_score = find_best_match(name, results.hits)
-        
+
         if not best_hit:
             console.print(f"[red]No suitable match found for '{name}'[/red]")
             return
-        
+
         slug = best_hit.slug
-        
+
         # Show what we found with confidence level
         confidence_msg = ""
         if best_score >= 80:
@@ -371,9 +371,9 @@ async def perform_add(
             confidence_msg = "[yellow](low confidence match)[/yellow]"
         else:
             confidence_msg = "[red](uncertain match - please verify)[/red]"
-        
+
         console.print(f"[cyan]Found:[/cyan] {slug} {confidence_msg}")
-        
+
         # If confidence is low and there are multiple results, show alternatives
         if best_score < 60 and len(results.hits) > 1:
             console.print("\n[yellow]Other possible matches:[/yellow]")
@@ -381,19 +381,19 @@ async def perform_add(
             table.add_column("#", style="dim", width=3)
             table.add_column("Slug", style="cyan")
             table.add_column("Score", justify="right", style="dim")
-            
+
             # Show top 5 alternatives
             scored_hits = []
             for hit in results.hits[:10]:
                 title = getattr(hit, 'title', '') or getattr(hit, 'name', '')
                 score = calculate_match_score(name, hit.slug, title)
                 scored_hits.append((hit, score))
-            
+
             scored_hits.sort(key=lambda x: x[1], reverse=True)
-            
+
             for idx, (hit, score) in enumerate(scored_hits[:5], 1):
                 table.add_row(str(idx), hit.slug, str(score))
-            
+
             console.print(table)
             console.print("\n[dim]Tip: Use the exact slug if the match is wrong[/dim]")
             console.print(f"[dim]Example: ModForge-CLI add {scored_hits[1][0].slug if len(scored_hits) > 1 else 'exact-slug'}[/dim]\n")
@@ -413,4 +413,4 @@ async def perform_add(
             except Exception as e:
                 console.print(f"[red]Failed to save manifest:[/red] {e}")
         else:
-            console.print(f"[yellow]{slug} is already in the manifest[/yellow]")
+            console.print(f"[yellow]{slug} is already in the manifest[/yellow]")

{modforge_cli-0.2.7 → modforge_cli-0.2.9}/src/modforge_cli/test.py

@@ -15,4 +15,4 @@ async def run() -> None:
         data = await res.json()
         print(data["hits"][0]["server_side"], data["hits"][0]["client_side"])
 
-asyncio.run(run())
+asyncio.run(run())

modforge_cli-0.2.7/src/modforge_cli/cli/__init__.py

@@ -1,7 +0,0 @@
-"""
-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.7 → modforge_cli-0.2.9}/src/modforge_cli/core/__init__.py

@@ -17,23 +17,23 @@ from .utils import (
 )
 
 __all__ = [
+    "Hit",
+    "Manifest",
+    "ModDownloader",
     "ModPolicy",
     "ModResolver",
-    "Manifest",
-    "Hit",
-    "SearchResult",
     "ProjectVersion",
     "ProjectVersionList",
-    "ModDownloader",
+    "SearchResult",
+    "detect_install_method",
     "ensure_config_file",
-    "install_fabric",
-    "run",
     "get_api_session",
     "get_manifest",
-    "self_update",
-    "perform_add",
-    "detect_install_method",
+    "install_fabric",
     "load_registry",
+    "perform_add",
+    "run",
     "save_registry_atomic",
+    "self_update",
     "setup_crash_logging",
 ]