unity-devkit 0.1.17__tar.gz → 0.1.19__tar.gz

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: unity-devkit
-Version: 0.1.17
+Version: 0.1.19
 Summary: Unity build, license, and CI tooling
 Requires-Python: >=3.13
 Requires-Dist: bashrun>=0.1.0

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unity-devkit"
-version = "0.1.17"
+version = "0.1.19"
 description = "Unity build, license, and CI tooling"
 requires-python = ">=3.13"
 dependencies = [

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/src/unity_devkit/build_unity.py

@@ -9,7 +9,7 @@ app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
 
 @app.command()
 def build_unity(
-    project: Annotated[str, typer.Option(help="Unity project name (catalog key in unity-devkit.json)")],
+    project: Annotated[str, typer.Option(help="Unity project name (the 'name' field of its unity-devkit.json)")],
     build: Annotated[str, typer.Option(help="Build target from the project's builds list (e.g. AndroidMobile)")],
     version: Annotated[
         str,

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/src/unity_devkit/ci_build_unity.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from typing import Annotated
 
 import typer
+from bashrun.bash import bash
 from pydantic_settings import BaseSettings
 
 from ci_devkit.cache import restore, save
@@ -28,7 +29,8 @@ def ci_build_unity(
     project_path: Annotated[Path, typer.Option(help="Path to Unity project")],
     platform: Annotated[str, typer.Option(help="Target platform")],
     cache_key: Annotated[str, typer.Option(help="Cache key prefix")],
-    registry: Annotated[str, typer.Option(help="OCI registry path")],
+    registry: Annotated[str, typer.Option(help="OCI registry path for the library cache")],
+    builds_registry: Annotated[str, typer.Option(help="OCI registry path for build artifacts")],
     run_number: Annotated[int, typer.Option(help="CI run number")] = 0,
     branch: Annotated[str, typer.Option(help="Git branch name")] = "dev",
     environment_preset: Annotated[
@@ -63,7 +65,7 @@ def ci_build_unity(
         unity_project_path = resolve_unity_project(project).path
         if unity_project_path.resolve() != project_path.resolve():
             raise SystemExit(
-                f"--project-path {project_path} does not match catalog entry '{project}' at {unity_project_path}"
+                f"--project-path {project_path} does not match discovered project '{project}' at {unity_project_path}"
             )
 
     with ci_step(f"Build {project} [{platform}]"):
@@ -96,3 +98,26 @@ def ci_build_unity(
                 for file in build_directory.rglob("*"):
                     if file.suffix in {".apk", ".exe"}:
                         shutil.copy2(file, artifact_directory / file.name)
+
+    with ci_step("Push build artifacts"):
+        artifact_directory = Path("/tmp/unity-builds")
+        if not artifact_directory.is_dir() or not any(artifact_directory.iterdir()):
+            print("No build artifacts to push")
+        else:
+            reference_base = f"{builds_registry}/{project}-{platform}".lower()
+            tags = (branch_slug, f"run-{run_number}")
+            if platform == "Linux":
+                staging = Path("/tmp/unity-builds-push")
+                staging.mkdir(parents=True, exist_ok=True)
+                tar_path = staging / "build.tar"
+                bash(f"tar -cf {tar_path} -C {artifact_directory} .")
+                try:
+                    for build_tag in tags:
+                        bash(f"oras push {reference_base}:{build_tag} build.tar", cwd=staging)
+                finally:
+                    tar_path.unlink(missing_ok=True)
+            else:
+                joined = " ".join(sorted(p.name for p in artifact_directory.iterdir() if p.is_file()))
+                for build_tag in tags:
+                    bash(f"oras push {reference_base}:{build_tag} {joined}", cwd=artifact_directory)
+            print(f"Pushed build artifacts: {reference_base} ({', '.join(tags)})")

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/src/unity_devkit/compile_check_unity.py

@@ -11,7 +11,7 @@ COMPILE_ERROR_SIGNATURES = ("error CS",)
 
 @app.command()
 def compile_check_unity(
-    project: Annotated[str, typer.Option(help="Unity project name (catalog key in unity-devkit.json)")],
+    project: Annotated[str, typer.Option(help="Unity project name (the 'name' field of its unity-devkit.json)")],
     execute_method: Annotated[
         str | None,
         typer.Option(help="Static method to run after load (Class.Method) — one editor session per invocation"),

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/src/unity_devkit/dispatch_workflow_generator.py

@@ -7,7 +7,7 @@ import typer
 from pydantic import BaseModel, ConfigDict
 
 from .compile_check_unity import COMPILE_ERROR_SIGNATURES
-from .projects import load_catalog
+from .projects import discover_projects
 from .player_build import prepare_unity_project, run_unity_batchmode
 
 app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
@@ -58,7 +58,7 @@ class EnvironmentDump(BaseModel):
 
 @app.command()
 def unity_dispatch(
-    project: Annotated[str, typer.Option(help="Unity project name (catalog key in unity-devkit.json)")],
+    project: Annotated[str, typer.Option(help="Unity project name (the 'name' field of its unity-devkit.json)")],
     output: Annotated[Path, typer.Option(help="Workflow file to write (or check with --check)")],
     build_workflow: Annotated[
         str,
@@ -69,13 +69,13 @@ def unity_dispatch(
     ],
     environment_config_class: Annotated[
         str | None,
-        typer.Option(help="Env class file path override (defaults to build-config.json's environment_config)"),
+        typer.Option(help="Env class file path override (defaults to unity-devkit.json's environment_config)"),
     ] = None,
     check: Annotated[
         bool, typer.Option("--check", help="Compare against the existing file instead of writing; fail on drift")
     ] = False,
 ) -> None:
-    projects = load_catalog()
+    projects = discover_projects()
     if project not in projects:
         raise SystemExit(f"Unknown project '{project}'. Valid: {', '.join(projects)}")
 

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/src/unity_devkit/install.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
-import json
 import os
+import shutil
 from pathlib import Path
-from typing import Annotated, Any
+from typing import Annotated
 
 import typer
-from bashrun.bash import bash, bash_handoff, bash_output
+from bashrun.bash import bash, bash_check, bash_handoff, bash_output
 
-from .projects import load_catalog
+from .projects import discover_projects
 from .player_build import build_player
 
 INSTALLABLE_TARGETS = {"AndroidMobile", "MagicLeap2", "Linux"}
@@ -27,9 +27,12 @@ def main(
     ] = None,
     branch: Annotated[
         str | None,
-        typer.Option("--branch", "-b", help="Branch to find latest successful run (default: current git branch)"),
+        typer.Option("--branch", "-b", help="Branch to pull the build from (default: current git branch)"),
+    ] = None,
+    run: Annotated[
+        int | None,
+        typer.Option("--run", "-r", help="Specific CI run number (github.run_number) to pull"),
     ] = None,
-    run: Annotated[int | None, typer.Option("--run", "-r", help="Specific GitHub Actions run ID")] = None,
     serial: Annotated[str | None, typer.Option("--serial", "-s", help="adb device serial")] = None,
     build_locally: Annotated[
         bool,
@@ -38,12 +41,20 @@ def main(
             "-B",
             help=(
                 "Build the project locally via `build-unity` and install the produced APK / "
-                "linux executable. Skips the GitHub Actions artifact lookup; --branch / --run are ignored."
+                "linux executable. Skips the OCI pull; --branch / --run are ignored."
             ),
         ),
     ] = False,
+    list_tags: Annotated[
+        bool,
+        typer.Option("--list", help="List available build tags for (project, target) and exit"),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Print what would be fetched/installed without doing it"),
+    ] = False,
 ) -> None:
-    projects = load_catalog()
+    projects = discover_projects()
 
     project_name = next((name for name in projects if name.lower() == project.lower()), None)
     if project_name is None:
@@ -68,51 +79,73 @@ def main(
     if serial and target_name not in ADB_TARGETS:
         print(f"Warning: --serial is ignored for target '{target_name}'")
 
+    package_name = f"{project_name}-{target_name}".lower()
+
+    if list_tags:
+        _require_oras()
+        reference_base = _resolve_reference_base(package_name)
+        _login_ghcr()
+        if bash_check(f"oras repo tags {reference_base}"):
+            output = bash_output(f"oras repo tags {reference_base}")
+            if output.strip():
+                print(f"Available tags for {reference_base}:")
+                print(output, end="")
+            else:
+                print(f"No tags found for {reference_base}")
+        else:
+            print(f"No tags found for {reference_base}")
+        return
+
     if build_locally:
         if branch or run:
             print("Warning: --branch / --run are ignored when --build is set")
+        if dry_run:
+            print(f"Would build {project_name} [{target_name}] locally")
+            if target_name in ADB_TARGETS:
+                serial_part = f" -s {serial}" if serial else ""
+                print(f"Would install: adb{serial_part} install <apk>")
+            elif target_name == "Linux":
+                print("Would launch the produced executable")
+            return
         produced = build_player(project_name, target_name)
         apks = [path for path in produced if path.suffix == ".apk"]
         executables = [path for path in produced if path.suffix in {".exe", ".x86_64"}]
     else:
-        artifact_name = f"{project_name}-{target_name}"
-
         resolved_branch = branch
         if not resolved_branch:
             resolved_branch = bash_output("git rev-parse --abbrev-ref HEAD").strip()
             if resolved_branch == "HEAD":
                 raise typer.BadParameter("HEAD is detached; pass --branch explicitly")
 
-        if run:
-            run_id = str(run)
-        else:
-            owner_repo = bash_output("gh repo view --json nameWithOwner --jq .nameWithOwner").strip()
-            output = bash_output(
-                f"gh api repos/{owner_repo}/actions/artifacts --method GET -f name={artifact_name}"
-                f" -f per_page=10 --jq .artifacts"
-            )
-            artifacts: list[dict[str, Any]] = json.loads(output)
-            run_id = next(
-                (
-                    str(artifact["workflow_run"]["id"])
-                    for artifact in artifacts
-                    if artifact["workflow_run"]["head_branch"] == resolved_branch
-                ),
-                None,
-            )
-            if run_id is None:
-                print(f"No artifact '{artifact_name}' found on branch '{resolved_branch}'")
-                raise SystemExit(1)
+        tag = f"run-{run}" if run else resolved_branch.replace("/", "-")
 
-        print(f"Run: {run_id}")
-        print(f"Artifact: {artifact_name}")
+        reference_base = _resolve_reference_base(package_name)
+        reference = f"{reference_base}:{tag}"
+        cache_path = CACHE_ROOT / tag / package_name
+
+        if dry_run:
+            print(f"Would pull: {reference}")
+            print(f"Cache: {cache_path}")
+            if target_name in ADB_TARGETS:
+                serial_part = f" -s {serial}" if serial else ""
+                print(f"Would install: adb{serial_part} install <apk>")
+            elif target_name == "Linux":
+                print("Would extract build.tar and launch the executable")
+            return
+
+        _require_oras()
+        _login_ghcr()
 
-        cache_path = CACHE_ROOT / run_id / artifact_name
         if cache_path.is_dir() and any(cache_path.iterdir()):
-            print(f"Using cached artifact: {cache_path}")
+            print(f"Using cached build: {cache_path}")
         else:
             cache_path.mkdir(parents=True, exist_ok=True)
-            bash(f"gh run download {run_id} --name {artifact_name} --dir {cache_path}")
+            bash(f"oras pull {reference} -o {cache_path}")
+            if target_name == "Linux":
+                tar_path = cache_path / "build.tar"
+                if tar_path.exists():
+                    bash(f"tar -xf {tar_path} -C {cache_path}")
+                    tar_path.unlink()
 
         apks = sorted(cache_path.rglob("*.apk"))
 
@@ -148,3 +181,22 @@ def main(
         os.chmod(executable, executable.stat().st_mode | 0o755)
         print(f"Launching: {executable.name}")
         bash_handoff(str(executable))
+
+
+def _require_oras() -> None:
+    if not shutil.which("oras"):
+        print("Error: oras is not on PATH. Install it:")
+        print("  macOS:  brew install oras")
+        print("  Linux:  https://oras.land/docs/install")
+        print("  Windows: scoop install oras")
+        raise SystemExit(1)
+
+
+def _resolve_reference_base(package_name: str) -> str:
+    owner_repo = bash_output("gh repo view --json nameWithOwner --jq .nameWithOwner").strip()
+    return f"ghcr.io/{owner_repo}/builds/{package_name}".lower()
+
+
+def _login_ghcr() -> None:
+    token = bash_output("gh auth token").strip()
+    bash("oras login ghcr.io --username oauth2 --password-stdin", stdin_text=token)

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/src/unity_devkit/lock_unity.py

@@ -2,7 +2,7 @@ from typing import Annotated
 
 import typer
 
-from .projects import load_catalog
+from .projects import discover_projects
 from .player_build import prepare_unity_project, run_unity_batchmode
 
 app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
@@ -10,7 +10,7 @@ app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
 
 @app.command()
 def lock_unity(project: Annotated[str | None, typer.Option(help="Limit to a specific project.")] = None) -> None:
-    config = load_catalog()
+    config = discover_projects()
 
     if project is not None and project not in config:
         raise typer.BadParameter(f"Unknown project '{project}'. Valid: {', '.join(config)}")

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/src/unity_devkit/matrix.py

@@ -1,12 +1,12 @@
 import json
 from pathlib import Path
 
-from .projects import load_catalog
+from .projects import discover_projects
 from .player_build import LICENSE_IMAGE_MODULE, PLATFORM_CONFIGS, UNITYCI_IMAGE_REVISION, read_editor_version
 
 
 def build_matrix() -> None:
-    projects = load_catalog()
+    projects = discover_projects()
     matrix: list[dict[str, str]] = []
     editor_versions: set[str] = set()
 
@@ -28,7 +28,7 @@ def build_matrix() -> None:
 
     if not editor_versions:
         raise SystemExit(
-            "No projects with builds declared — build-unity-matrix needs at least one unity-devkit.json entry with a 'builds' list"
+            "No projects with builds declared — build-unity-matrix needs at least one unity-devkit.json with a non-empty 'platforms' map"
         )
     license_version = max(editor_versions)
     print(f"matrix={json.dumps({'include': matrix})}")
@@ -36,7 +36,7 @@ def build_matrix() -> None:
 
 
 def compile_check_matrix() -> None:
-    projects = load_catalog()
+    projects = discover_projects()
     matrix: list[dict[str, str]] = []
     editor_versions: set[str] = set()
 

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/src/unity_devkit/player_build.py

@@ -9,7 +9,7 @@ from typing import TypedDict
 
 from bashrun.bash import CalledProcessError, bash, bash_pipe
 
-from .projects import CatalogEntry, load_catalog
+from .projects import ProjectEntry, discover_projects
 
 
 class PlatformConfig(TypedDict):
@@ -135,8 +135,8 @@ def editor_version(project_path: Path) -> str | None:
     return None
 
 
-def resolve_unity_project(project: str) -> CatalogEntry:
-    projects = load_catalog()
+def resolve_unity_project(project: str) -> ProjectEntry:
+    projects = discover_projects()
     if project not in projects:
         raise SystemExit(f"Unknown project '{project}'. Valid: {', '.join(projects)}")
     return projects[project]
@@ -182,7 +182,7 @@ def build_player(
     valid_builds = project_config.builds or []
     if not valid_builds:
         raise SystemExit(
-            f"Project '{project}' declares no builds — add a 'builds' list to its entry in unity-devkit.json"
+            f"Project '{project}' declares no builds — add platform keys to its unity-devkit.json 'platforms' map"
         )
     if build not in valid_builds:
         raise SystemExit(f"Unknown build '{build}' for project '{project}'. Valid: {', '.join(valid_builds)}")

unity_devkit-0.1.19/src/unity_devkit/projects.py

@@ -0,0 +1,73 @@
+import os
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, field_validator
+
+BUILD_CONFIG_FILENAME = "unity-devkit.json"
+PROJECT_MARKER = Path("ProjectSettings") / "ProjectVersion.txt"
+PRUNE_DIRECTORIES = {".git", "Library", "Temp", "obj", "Build", "node_modules", "__pycache__"}
+
+
+class BuildConfigFile(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    name: str
+    platforms: dict[str, Any] | None = None
+
+    @field_validator("name")
+    @classmethod
+    def nonempty_name(cls, value: str) -> str:
+        if not value.strip():
+            raise ValueError("unity-devkit.json 'name' must be a non-empty string")
+        return value
+
+
+class ProjectEntry(BaseModel):
+    path: Path
+    builds: list[str] | None = None
+
+
+def discover_projects() -> dict[str, ProjectEntry]:
+    root = Path.cwd()
+    discovered: dict[str, ProjectEntry] = {}
+    first_seen: dict[str, Path] = {}
+
+    for directory in visible_directories(root):
+        config_path = directory / BUILD_CONFIG_FILENAME
+        if not config_path.is_file():
+            continue
+        if not (directory / PROJECT_MARKER).is_file():
+            raise SystemExit(
+                f"{config_path} sits in {directory}, which is not a Unity project: missing {PROJECT_MARKER}"
+            )
+        parsed = BuildConfigFile.model_validate_json(config_path.read_text(encoding="utf-8"))
+        if parsed.name in discovered:
+            raise SystemExit(
+                f"Duplicate project name '{parsed.name}' — declared at {config_path} "
+                f"and previously at {first_seen[parsed.name]}"
+            )
+        first_seen[parsed.name] = config_path
+        builds = list(parsed.platforms.keys()) if parsed.platforms else None
+        discovered[parsed.name] = ProjectEntry(path=directory, builds=builds)
+
+    if not discovered:
+        raise SystemExit(
+            f"No {BUILD_CONFIG_FILENAME} found under {root} — declare Unity projects with a "
+            f"{BUILD_CONFIG_FILENAME} per project root (carrying a 'name' field; 'platforms' "
+            f"keys are the build targets)"
+        )
+    return discovered
+
+
+def visible_directories(root: Path) -> Iterator[Path]:
+    for directory, subdirectories, _filenames in os.walk(root):
+        subdirectories[:] = sorted(
+            name for name in subdirectories if name not in PRUNE_DIRECTORIES and not name.startswith(".")
+        )
+        yield Path(directory)
+
+
+def directories_containing(root: Path, filename: str) -> list[Path]:
+    return [directory for directory in visible_directories(root) if (directory / filename).is_file()]

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/src/unity_devkit/test_unity.py

@@ -5,7 +5,7 @@ from typing import Annotated
 
 import typer
 
-from .projects import load_catalog
+from .projects import discover_projects
 from .player_build import run_unity_batchmode
 
 app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
@@ -13,13 +13,13 @@ app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
 
 @app.command()
 def main(
-    project: Annotated[str, typer.Option(help="Unity project name (catalog key in unity-devkit.json)")],
+    project: Annotated[str, typer.Option(help="Unity project name (the 'name' field of its unity-devkit.json)")],
     test_platform: Annotated[str, typer.Option(help="Unity test platform (EditMode or PlayMode)")] = "EditMode",
     results: Annotated[Path, typer.Option(help="Output path for NUnit XML results")] = Path(
         "artifacts/unity-test-results.xml"
     ),
 ) -> None:
-    projects = load_catalog()
+    projects = discover_projects()
     if project not in projects:
         raise SystemExit(f"Unknown project '{project}'. Valid: {', '.join(projects)}")
 

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/tests/test_build_player.py

@@ -21,10 +21,10 @@ def write_repository(tmp_path: Path, project_settings: str, *, builds: list[str]
     (project / "ProjectSettings").mkdir(parents=True)
     (project / "ProjectSettings" / "ProjectSettings.asset").write_text(project_settings)
     (project / "ProjectSettings" / "ProjectVersion.txt").write_text("m_EditorVersion: 6000.0.66f1\n")
-    entry: dict[str, object] = {"path": "apps/Tool"}
+    config: dict[str, object] = {"name": "tool"}
     if builds is not None:
-        entry["builds"] = builds
-    (tmp_path / "unity-devkit.json").write_text(json.dumps({"tool": entry}))
+        config["platforms"] = {platform: {} for platform in builds}
+    (project / "unity-devkit.json").write_text(json.dumps(config))
     return project
 
 

{unity_devkit-0.1.17 → unity_devkit-0.1.19}/tests/test_matrix.py

@@ -6,17 +6,20 @@ import pytest
 from unity_devkit import matrix
 
 
-def write_repository(tmp_path: Path, entry: dict[str, object]) -> None:
+def write_repository(tmp_path: Path, builds: list[str] | None = None) -> None:
     project = tmp_path / "apps" / "Tool"
     (project / "ProjectSettings").mkdir(parents=True)
     (project / "ProjectSettings" / "ProjectVersion.txt").write_text("m_EditorVersion: 6000.0.66f1\n")
-    (tmp_path / "unity-devkit.json").write_text(json.dumps({"tool": entry}))
+    config: dict[str, object] = {"name": "tool"}
+    if builds is not None:
+        config["platforms"] = {platform: {} for platform in builds}
+    (project / "unity-devkit.json").write_text(json.dumps(config))
 
 
 def test_matrix_emits_entries_from_catalog(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:
-    write_repository(tmp_path, {"path": "apps/Tool", "builds": ["Linux"]})
+    write_repository(tmp_path, builds=["Linux"])
     monkeypatch.chdir(tmp_path)
 
     matrix.build_matrix()
@@ -37,7 +40,7 @@ def test_matrix_emits_entries_from_catalog(
 
 
 def test_matrix_fails_without_builds(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    write_repository(tmp_path, {"path": "apps/Tool"})
+    write_repository(tmp_path)
     monkeypatch.chdir(tmp_path)
 
     with pytest.raises(SystemExit, match="No projects with builds declared"):
@@ -47,7 +50,7 @@ def test_matrix_fails_without_builds(tmp_path: Path, monkeypatch: pytest.MonkeyP
 def test_check_matrix_includes_path_only_projects(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:
-    write_repository(tmp_path, {"path": "apps/Tool"})
+    write_repository(tmp_path)
     monkeypatch.chdir(tmp_path)
 
     matrix.compile_check_matrix()

unity_devkit-0.1.19/tests/test_projects.py

@@ -0,0 +1,120 @@
+import json
+from pathlib import Path
+
+import pytest
+from pydantic import ValidationError
+
+from unity_devkit.projects import directories_containing, discover_projects
+
+
+def create_unity_project(root: Path, relative: str) -> Path:
+    project = root / relative
+    (project / "ProjectSettings").mkdir(parents=True)
+    (project / "ProjectSettings" / "ProjectVersion.txt").write_text("m_EditorVersion: 6000.0.66f1\n")
+    return project
+
+
+def write_build_config(project_dir: Path, config: dict[str, object]) -> Path:
+    config_path = project_dir / "unity-devkit.json"
+    config_path.write_text(json.dumps(config))
+    return config_path
+
+
+def test_discovers_project_with_platforms_keys_as_builds(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    project = create_unity_project(tmp_path, "Alpha")
+    write_build_config(project, {"name": "Alpha", "platforms": {"Linux": {}, "AndroidMobile": {}}})
+    monkeypatch.chdir(tmp_path)
+
+    projects = discover_projects()
+
+    assert set(projects) == {"Alpha"}
+    assert projects["Alpha"].path == project
+    assert projects["Alpha"].builds == ["Linux", "AndroidMobile"]
+
+
+def test_name_is_decoupled_from_directory_name(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    project = create_unity_project(tmp_path, "apps/capture-tool")
+    write_build_config(project, {"name": "capture"})
+    monkeypatch.chdir(tmp_path)
+
+    projects = discover_projects()
+
+    assert set(projects) == {"capture"}
+    assert projects["capture"].path == project
+
+
+def test_path_only_project_has_no_builds(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    project = create_unity_project(tmp_path, "Harness")
+    write_build_config(project, {"name": "Harness"})
+    monkeypatch.chdir(tmp_path)
+
+    projects = discover_projects()
+
+    assert set(projects) == {"Harness"}
+    assert projects["Harness"].builds is None
+
+
+def test_no_build_config_found_fails(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(SystemExit, match=r"No unity-devkit\.json found"):
+        discover_projects()
+
+
+def test_config_outside_unity_project_fails(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    not_a_project = tmp_path / "not-a-project"
+    not_a_project.mkdir()
+    write_build_config(not_a_project, {"name": "broken"})
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(SystemExit, match="not a Unity project"):
+        discover_projects()
+
+
+def test_duplicate_project_name_fails(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    first = create_unity_project(tmp_path, "apps/one")
+    write_build_config(first, {"name": "dup"})
+    second = create_unity_project(tmp_path, "apps/two")
+    write_build_config(second, {"name": "dup"})
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(SystemExit, match="Duplicate project name 'dup'"):
+        discover_projects()
+
+
+def test_ignores_csharp_owned_fields(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    project = create_unity_project(tmp_path, "App")
+    write_build_config(
+        project,
+        {
+            "name": "App",
+            "environment_config": "Assets/App/UnityEnv.cs",
+            "platforms": {"AndroidMobile": {"render_pipeline": "Assets/Settings/Android.asset"}},
+        },
+    )
+    monkeypatch.chdir(tmp_path)
+
+    projects = discover_projects()
+
+    assert projects["App"].builds == ["AndroidMobile"]
+
+
+def test_missing_name_field_fails(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    project = create_unity_project(tmp_path, "Alpha")
+    write_build_config(project, {"platforms": {"Linux": {}}})
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(ValidationError):
+        discover_projects()
+
+
+def test_directories_containing_honors_prune_list(tmp_path: Path) -> None:
+    vendored = tmp_path / "vendor" / "Library" / "SomeProject"
+    (vendored / "ProjectSettings").mkdir(parents=True)
+    (vendored / "ProjectSettings" / "ProjectVersion.txt").write_text("m_EditorVersion: 6000.0.66f1\n")
+    real = create_unity_project(tmp_path, "Real")
+
+    settings_directories = directories_containing(tmp_path, "ProjectVersion.txt")
+
+    assert real / "ProjectSettings" in settings_directories
+    assert vendored / "ProjectSettings" not in settings_directories

unity_devkit-0.1.17/src/unity_devkit/projects.py

@@ -1,55 +0,0 @@
-import os
-from collections.abc import Iterator
-from pathlib import Path
-
-from pydantic import BaseModel, ConfigDict, TypeAdapter, field_validator
-
-CATALOG_FILENAME = "unity-devkit.json"
-PROJECT_MARKER = Path("ProjectSettings") / "ProjectVersion.txt"
-PRUNE_DIRECTORIES = {".git", "Library", "Temp", "obj", "Build", "node_modules", "__pycache__"}
-
-
-class CatalogEntry(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    path: Path
-    builds: list[str] | None = None
-
-    @field_validator("path")
-    @classmethod
-    def anchor_relative_path(cls, value: Path) -> Path:
-        return value if value.is_absolute() else Path.cwd() / value
-
-
-CATALOG_ADAPTER = TypeAdapter(dict[str, CatalogEntry])
-
-
-def load_catalog() -> dict[str, CatalogEntry]:
-    catalog_path = Path.cwd() / CATALOG_FILENAME
-    if not catalog_path.is_file():
-        raise SystemExit(
-            f"No {CATALOG_FILENAME} catalog at {catalog_path} — declare Unity projects as catalog entries at the repo root"
-        )
-
-    catalog = CATALOG_ADAPTER.validate_json(catalog_path.read_text(encoding="utf-8"))
-    if not catalog:
-        raise SystemExit(f"{catalog_path} declares no projects — at least one catalog entry is required")
-
-    for name, entry in catalog.items():
-        if not (entry.path / PROJECT_MARKER).is_file():
-            raise SystemExit(
-                f"Catalog entry '{name}' points at {entry.path}, which is not a Unity project: missing {PROJECT_MARKER}"
-            )
-    return catalog
-
-
-def visible_directories(root: Path) -> Iterator[Path]:
-    for directory, subdirectories, _filenames in os.walk(root):
-        subdirectories[:] = sorted(
-            name for name in subdirectories if name not in PRUNE_DIRECTORIES and not name.startswith(".")
-        )
-        yield Path(directory)
-
-
-def directories_containing(root: Path, filename: str) -> list[Path]:
-    return [directory for directory in visible_directories(root) if (directory / filename).is_file()]

unity_devkit-0.1.17/tests/test_projects.py

@@ -1,88 +0,0 @@
-import json
-from pathlib import Path
-
-import pytest
-from pydantic import ValidationError
-
-from unity_devkit.projects import directories_containing, load_catalog
-
-
-def write_catalog(root: Path, catalog: dict[str, object]) -> Path:
-    catalog_path = root / "unity-devkit.json"
-    catalog_path.write_text(json.dumps(catalog))
-    return catalog_path
-
-
-def create_unity_project(root: Path, relative: str) -> Path:
-    project = root / relative
-    (project / "ProjectSettings").mkdir(parents=True)
-    (project / "ProjectSettings" / "ProjectVersion.txt").write_text("m_EditorVersion: 6000.0.66f1\n")
-    return project
-
-
-def test_catalog_entry_loads_with_intent_fields(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    create_unity_project(tmp_path, "Alpha")
-    write_catalog(tmp_path, {"Alpha": {"path": "Alpha", "builds": ["Linux"]}})
-    monkeypatch.chdir(tmp_path)
-
-    projects = load_catalog()
-
-    assert set(projects) == {"Alpha"}
-    assert projects["Alpha"].path == Path.cwd() / "Alpha"
-    assert projects["Alpha"].builds == ["Linux"]
-
-
-def test_catalog_name_is_decoupled_from_directory_name(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    create_unity_project(tmp_path, "apps/capture-tool")
-    write_catalog(tmp_path, {"capture": {"path": "apps/capture-tool"}})
-    monkeypatch.chdir(tmp_path)
-
-    projects = load_catalog()
-
-    assert set(projects) == {"capture"}
-    assert projects["capture"].path == Path.cwd() / "apps" / "capture-tool"
-
-
-def test_missing_catalog_fails(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.chdir(tmp_path)
-
-    with pytest.raises(SystemExit, match=r"No unity-devkit\.json catalog"):
-        load_catalog()
-
-
-def test_empty_catalog_fails(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    write_catalog(tmp_path, {})
-    monkeypatch.chdir(tmp_path)
-
-    with pytest.raises(SystemExit, match="declares no projects"):
-        load_catalog()
-
-
-def test_entry_outside_unity_project_fails(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    (tmp_path / "not-a-project").mkdir()
-    write_catalog(tmp_path, {"broken": {"path": "not-a-project"}})
-    monkeypatch.chdir(tmp_path)
-
-    with pytest.raises(SystemExit, match="not a Unity project"):
-        load_catalog()
-
-
-def test_unknown_entry_key_fails(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    create_unity_project(tmp_path, "Alpha")
-    write_catalog(tmp_path, {"Alpha": {"path": "Alpha", "unity-build": True}})
-    monkeypatch.chdir(tmp_path)
-
-    with pytest.raises(ValidationError):
-        load_catalog()
-
-
-def test_directories_containing_honors_prune_list(tmp_path: Path) -> None:
-    vendored = tmp_path / "vendor" / "Library" / "SomeProject"
-    (vendored / "ProjectSettings").mkdir(parents=True)
-    (vendored / "ProjectSettings" / "ProjectVersion.txt").write_text("m_EditorVersion: 6000.0.66f1\n")
-    real = create_unity_project(tmp_path, "Real")
-
-    settings_directories = directories_containing(tmp_path, "ProjectVersion.txt")
-
-    assert real / "ProjectSettings" in settings_directories
-    assert vendored / "ProjectSettings" not in settings_directories