implements packer PR-04 workspace scan and studio read adapter

This commit is contained in:
2026-03-24 13:42:42 +00:00
parent 12f2311d08
commit 924ab587e8
11 changed files with 486 additions and 1 deletions
+1
View File
@@ -5,6 +5,7 @@ plugins {
dependencies {
implementation(project(":prometeu-infra"))
implementation(project(":prometeu-packer"))
implementation(project(":prometeu-compiler:prometeu-compiler-core"))
implementation(project(":prometeu-compiler:prometeu-build-pipeline"))
implementation(project(":prometeu-compiler:prometeu-frontend-registry"))
@@ -56,7 +56,7 @@ public final class AssetWorkspace implements Workspace {
private String searchQuery = "";
public AssetWorkspace(ProjectReference projectReference) {
this(projectReference, new FileSystemAssetWorkspaceService(), new FileSystemAssetWorkspaceMutationService());
this(projectReference, new PackerBackedAssetWorkspaceService(), new FileSystemAssetWorkspaceMutationService());
}
public AssetWorkspace(
@@ -0,0 +1,101 @@
package p.studio.workspaces.assets;
import p.packer.api.PackerProjectContext;
import p.packer.api.assets.PackerAssetDetails;
import p.packer.api.assets.PackerAssetState;
import p.packer.api.assets.PackerAssetSummary;
import p.packer.api.diagnostics.PackerDiagnostic;
import p.packer.api.diagnostics.PackerDiagnosticSeverity;
import p.packer.api.workspace.GetAssetDetailsRequest;
import p.packer.api.workspace.ListAssetsRequest;
import p.packer.workspace.FileSystemPackerWorkspaceService;
import p.studio.projects.ProjectReference;
import java.nio.file.Path;
import java.util.List;
import java.util.Objects;
public final class PackerBackedAssetWorkspaceService implements AssetWorkspaceService {
private final FileSystemPackerWorkspaceService packerWorkspaceService;
public PackerBackedAssetWorkspaceService() {
this(new FileSystemPackerWorkspaceService());
}
public PackerBackedAssetWorkspaceService(FileSystemPackerWorkspaceService packerWorkspaceService) {
this.packerWorkspaceService = Objects.requireNonNull(packerWorkspaceService, "packerWorkspaceService");
}
@Override
public AssetWorkspaceSnapshot loadWorkspace(ProjectReference projectReference) {
final var result = packerWorkspaceService.listAssets(new ListAssetsRequest(project(projectReference)));
final List<AssetWorkspaceAssetSummary> assets = result.assets().stream()
.map(this::mapSummary)
.toList();
return new AssetWorkspaceSnapshot(assets);
}
@Override
public AssetWorkspaceAssetDetails loadAssetDetails(ProjectReference projectReference, AssetWorkspaceSelectionKey selectionKey) {
final String assetReference = switch (selectionKey) {
case AssetWorkspaceSelectionKey.ManagedAsset managedAsset -> Integer.toString(managedAsset.assetId());
case AssetWorkspaceSelectionKey.OrphanAsset orphanAsset -> relativeAssetRoot(projectReference, orphanAsset.assetRoot());
};
final var result = packerWorkspaceService.getAssetDetails(new GetAssetDetailsRequest(project(projectReference), assetReference));
return mapDetails(result.details());
}
private AssetWorkspaceAssetSummary mapSummary(PackerAssetSummary summary) {
final AssetWorkspaceAssetState state = toStudioState(summary);
final AssetWorkspaceSelectionKey selectionKey = state == AssetWorkspaceAssetState.MANAGED
? new AssetWorkspaceSelectionKey.ManagedAsset(summary.identity().assetId())
: new AssetWorkspaceSelectionKey.OrphanAsset(summary.identity().assetRoot());
return new AssetWorkspaceAssetSummary(
selectionKey,
summary.identity().assetName(),
state,
summary.identity().assetId(),
summary.assetFamily(),
summary.identity().assetRoot(),
summary.preloadEnabled(),
summary.hasDiagnostics());
}
private AssetWorkspaceAssetDetails mapDetails(PackerAssetDetails details) {
return new AssetWorkspaceAssetDetails(
mapSummary(details.summary()),
details.outputFormat(),
details.outputCodec(),
details.inputsByRole(),
details.diagnostics().stream().map(this::mapDiagnostic).toList());
}
private AssetWorkspaceDiagnostic mapDiagnostic(PackerDiagnostic diagnostic) {
return new AssetWorkspaceDiagnostic(
switch (diagnostic.severity()) {
case ERROR -> AssetWorkspaceDiagnosticSeverity.BLOCKER;
case WARNING -> AssetWorkspaceDiagnosticSeverity.WARNING;
case INFO -> AssetWorkspaceDiagnosticSeverity.HINT;
},
diagnostic.message());
}
private AssetWorkspaceAssetState toStudioState(PackerAssetSummary summary) {
if (summary.state() == PackerAssetState.MANAGED) {
return AssetWorkspaceAssetState.MANAGED;
}
return summary.identity().assetId() != null ? AssetWorkspaceAssetState.MANAGED : AssetWorkspaceAssetState.ORPHAN;
}
private PackerProjectContext project(ProjectReference projectReference) {
final ProjectReference reference = Objects.requireNonNull(projectReference, "projectReference");
return new PackerProjectContext(reference.name(), reference.rootPath());
}
private String relativeAssetRoot(ProjectReference projectReference, Path assetRoot) {
return projectReference.rootPath().resolve("assets").toAbsolutePath().normalize()
.relativize(assetRoot.toAbsolutePath().normalize())
.toString()
.replace('\\', '/');
}
}
@@ -0,0 +1,93 @@
package p.studio.workspaces.assets;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import p.studio.projects.ProjectReference;
import java.nio.file.Files;
import java.nio.file.Path;
import static org.junit.jupiter.api.Assertions.*;
final class PackerBackedAssetWorkspaceServiceTest {
@TempDir
Path tempDir;
@Test
void loadsWorkspaceThroughPackerBackedSnapshot() throws Exception {
final Path projectRoot = tempDir.resolve("main");
final Path managedRoot = projectRoot.resolve("assets/ui/atlas");
final Path orphanRoot = projectRoot.resolve("assets/orphans/ui_sounds");
Files.createDirectories(managedRoot);
Files.createDirectories(orphanRoot);
Files.createDirectories(projectRoot.resolve("assets/.prometeu"));
Files.writeString(managedRoot.resolve("asset.json"), """
{
"schema_version": 1,
"name": "ui_atlas",
"type": "image_bank",
"inputs": { "sprites": ["sprites/confirm.png"] },
"output": { "format": "TILES/indexed_v1", "codec": "RAW" },
"preload": { "enabled": true }
}
""");
Files.writeString(orphanRoot.resolve("asset.json"), """
{
"schema_version": 1,
"name": "ui_sounds",
"type": "sound_bank",
"inputs": { "sources": ["confirm.wav"] },
"output": { "format": "SOUND/bank_v1", "codec": "RAW" },
"preload": { "enabled": false }
}
""");
Files.writeString(projectRoot.resolve("assets/.prometeu/index.json"), """
{
"schema_version": 1,
"next_asset_id": 2,
"assets": [
{
"asset_id": 1,
"asset_uuid": "uuid-1",
"root": "ui/atlas"
}
]
}
""");
final PackerBackedAssetWorkspaceService service = new PackerBackedAssetWorkspaceService();
final AssetWorkspaceSnapshot snapshot = service.loadWorkspace(project("Main", projectRoot));
assertEquals(2, snapshot.assets().size());
assertTrue(snapshot.assets().stream().anyMatch(asset -> asset.state() == AssetWorkspaceAssetState.MANAGED));
assertTrue(snapshot.assets().stream().anyMatch(asset -> asset.state() == AssetWorkspaceAssetState.ORPHAN));
}
@Test
void mapsInvalidDetailsToStudioDiagnostics() throws Exception {
final Path projectRoot = tempDir.resolve("main");
final Path invalidRoot = projectRoot.resolve("assets/bad");
Files.createDirectories(invalidRoot);
Files.writeString(invalidRoot.resolve("asset.json"), """
{
"schema_version": 1,
"type": "image_bank"
}
""");
final PackerBackedAssetWorkspaceService service = new PackerBackedAssetWorkspaceService();
final AssetWorkspaceAssetDetails details = service.loadAssetDetails(
project("Main", projectRoot),
new AssetWorkspaceSelectionKey.OrphanAsset(invalidRoot));
assertEquals("unknown", details.outputFormat());
assertFalse(details.diagnostics().isEmpty());
assertEquals(AssetWorkspaceDiagnosticSeverity.BLOCKER, details.diagnostics().getFirst().severity());
}
private ProjectReference project(String name, Path root) {
return new ProjectReference(name, "1.0.0", "pbs", 1, root);
}
}