expose manifest-driven project knowledge through MCP

This commit is contained in:
2026-09-29 08:30:38 +01:00
parent 9f61f9c07d
commit 58f11a8123
14 changed files with 665 additions and 13 deletions
@@ -0,0 +1,193 @@
package p.studio.app.compiler;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import p.studio.api.automation.*;
import p.studio.compiler.FrontendRegistryService;
import p.studio.compiler.models.FrontendSpec;
import p.studio.compiler.services.FrontendPhaseService;
import p.studio.compiler.services.FrontendProvider;
import p.studio.core.project.*;
import p.studio.utilities.structures.ReadOnlySet;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
class CompilerProjectKnowledgeTest {
@TempDir Path directory;
final ObjectMapper mapper = new ObjectMapper();
final ProjectAccessRegistry access = new ProjectAccessRegistry();
CompilerProjectKnowledge knowledge() {
return new CompilerProjectKnowledge(access,
new ProjectCatalogService(directory, mapper, new ProjectLocalStudioSetupStore(mapper)), mapper);
}
@Test void pbsContextIsReadOnlyManifestDrivenAndVersionsAreIndependent() throws Exception {
Path root = project("game", "pbs", "1", "[]");
access.register(root, () -> { throw new AssertionError("No grant needed"); }, () -> true);
var result = knowledge().context(root);
var language = result.languages().getFirst();
assertEquals("pbs", language.id());
assertTrue(language.primary());
assertEquals(List.of("barrel", "pbs"), language.extensions());
assertEquals(List.of(root.resolve("src")), language.sourceRoots());
assertFalse(language.languageVersion().known());
assertFalse(language.compilerVersion().known());
assertEquals("1", language.sdkVersion().value());
assertTrue(language.sdkVersion().source().contains("supported by installed"));
assertSupport(language, "build", ProjectKnowledge.Support.SUPPORTED);
assertSupport(language, "definition", ProjectKnowledge.Support.SUPPORTED);
assertSupport(language, "typeHierarchy", ProjectKnowledge.Support.UNSUPPORTED);
assertEquals(List.of(root), result.editableRoots());
assertFalse(result.libraries().getFirst().editable());
assertTrue(result.libraries().getFirst().id().startsWith("sdk:pbs:"));
assertTrue(result.references().isEmpty());
assertTrue(result.limitations().stream().anyMatch(value -> value.contains("DOCUMENTATION_UNAVAILABLE")));
assertFalse(Files.exists(root.resolve(".workspace")));
assertFalse(Files.exists(root.resolve(".studio")));
}
@Test void rereadsSavedManifestAndNeverFallsBackForAnUnknownLanguageOrSdk() throws Exception {
Path root = project("game", "pbs", "1", "[]");
var registration = access.register(root, () -> () -> {}, () -> true);
var knowledge = knowledge();
assertEquals("pbs", knowledge.context(root).languages().getFirst().id());
project("game", "missing-language", "9", "[]");
var unknown = knowledge.context(root).languages().getFirst();
assertEquals("missing-language", unknown.id());
assertTrue(unknown.extensions().isEmpty());
assertTrue(unknown.sourceRoots().isEmpty());
assertSupport(unknown, "build", ProjectKnowledge.Support.UNSUPPORTED);
assertEquals("9", unknown.sdkVersion().value());
assertTrue(unknown.sdkVersion().source().contains("requested"));
project("game", "pbs", "999", "[]");
assertSupport(knowledge.context(root).languages().getFirst(), "build", ProjectKnowledge.Support.UNSUPPORTED);
registration.unsubscribe();
assertEquals(AutomationFailure.Code.PROJECT_NOT_OPEN,
assertThrows(AutomationException.class, () -> knowledge.context(root)).failure().code());
}
@Test void alternateInstalledMetadataUsesItsOwnExtensionsSdkAndLspCapabilitiesWithoutCompiling() throws Exception {
String id = "context-test-language";
FrontendRegistryService.register(new FrontendProvider() {
@Override public FrontendSpec specification() {
return FrontendSpec.builder().languageId(id).allowedExtensions(ReadOnlySet.from("alt"))
.sourceRoots(ReadOnlySet.from("code")).stdlibVersions(List.of(FrontendSpec.Stdlib.asDefault(7)))
// Reuse only a visual-theme fixture; no PBS compiler or language service is installed for this ID.
.semanticPresentation(FrontendRegistryService.require("pbs").specification().getSemanticPresentation()).build();
}
@Override public FrontendPhaseService compiler() { throw new AssertionError("Discovery must not compile"); }
});
try {
Path root = project("alternate", id, "7", "[]");
access.register(root, () -> () -> {}, () -> true);
var language = knowledge().context(root).languages().getFirst();
assertEquals(id, language.id());
assertEquals(List.of("alt"), language.extensions());
assertEquals(List.of(root.resolve("code")), language.sourceRoots());
assertEquals("7", language.sdkVersion().value());
assertSupport(language, "build", ProjectKnowledge.Support.SUPPORTED);
assertSupport(language, "definition", ProjectKnowledge.Support.UNSUPPORTED);
assertSupport(language, "formatting", ProjectKnowledge.Support.UNSUPPORTED);
assertFalse(language.languageVersion().known());
} finally { FrontendRegistryService.unregister(id); }
}
@Test void localExternalRegistryAndSymlinkLibrariesHaveCanonicalScopes() throws Exception {
Path root = project("game", "pbs", "1", """
[{"path":"lib"},{"path":"external-alias"},{"name":"registered","version":"1.0.0"}]
""");
Path local = project("game/lib", "pbs", "1", "[]");
Path external = project("external", "pbs", "1", "[]");
Path registered = project("game/vendor", "pbs", "1", "[]");
Files.createSymbolicLink(root.resolve("external-alias"), external);
Files.createDirectories(root.resolve(".workspace/repos"));
mapper.writeValue(root.resolve(".workspace/repos/registry.json").toFile(), java.util.Map.of("registered@1.0.0", registered.toString()));
access.register(root, () -> () -> {}, () -> true);
var result = knowledge().context(root);
assertTrue(library(result, local).editable());
assertFalse(library(result, external).editable());
assertFalse(library(result, registered).editable());
assertTrue(result.readOnlyRoots().contains(external));
assertTrue(result.readOnlyRoots().contains(registered));
}
@Test void externalSourceRootsAreReadOnlyAndUnresolvedDependenciesAreVisible() throws Exception {
Path root = project("game", "pbs", "1", "[{\"path\":\"missing\"}]");
Path externalSources = Files.createDirectory(directory.resolve("external-sources")).toRealPath();
Files.createSymbolicLink(root.resolve("src"), externalSources);
access.register(root, () -> () -> {}, () -> true);
var result = knowledge().context(root);
assertTrue(result.readOnlyRoots().contains(externalSources));
assertTrue(result.libraries().stream().anyMatch(library -> library.id().equals("missing") && library.roots().isEmpty() && !library.editable()));
assertSupport(result.languages().getFirst(), "build", ProjectKnowledge.Support.UNSUPPORTED);
assertTrue(result.limitations().stream().anyMatch(value -> value.contains("could not be resolved")));
assertFalse(Files.exists(root.resolve(".workspace")));
}
@Test void invalidOrMissingManifestIsATypedFailureNotAStaleContext() throws Exception {
Path root = project("game", "pbs", "1", "[]");
access.register(root, () -> () -> {}, () -> true);
Files.writeString(root.resolve("prometeu.json"), "{}");
assertEquals(AutomationFailure.Code.INFRASTRUCTURE_FAILURE,
assertThrows(AutomationException.class, () -> knowledge().context(root)).failure().code());
Files.delete(root.resolve("prometeu.json"));
assertEquals(AutomationFailure.Code.INFRASTRUCTURE_FAILURE,
assertThrows(AutomationException.class, () -> knowledge().context(root)).failure().code());
}
@Test void transitiveReadOnlyProvenanceWinsAndMixedLanguagesRemainVisible() throws Exception {
Path root = project("game", "pbs", "1", "[{\"path\":\"lib\"},{\"path\":\"../external\"}]");
Path local = project("game/lib", "pbs", "1", "[]");
Path external = project("external", "unknown-language", "2", "[{\"path\":\"lib\"}]");
Files.createDirectories(root.resolve(".workspace/repos"));
Files.writeString(root.resolve(".workspace/repos/registry.json"), "{}");
access.register(root, () -> () -> {}, () -> true);
var result = knowledge().context(root);
assertFalse(library(result, local).editable());
assertFalse(library(result, external).editable());
assertTrue(result.readOnlyRoots().contains(local.resolve("src")));
assertEquals(List.of("pbs", "unknown-language"), result.languages().stream().map(ProjectKnowledge.Language::id).toList());
assertFalse(result.languages().get(1).primary());
assertSupport(result.languages().getFirst(), "build", ProjectKnowledge.Support.UNSUPPORTED);
}
@Test void incompleteInstalledLspMetadataReportsUnknownInsteadOfInventingCapabilities() throws Exception {
String id = "incomplete-test-language";
FrontendRegistryService.register(new FrontendProvider() {
@Override public FrontendSpec specification() {
return FrontendSpec.builder().languageId(id).allowedExtensions(ReadOnlySet.from("alt"))
.sourceRoots(ReadOnlySet.from("code")).build();
}
@Override public FrontendPhaseService compiler() { throw new AssertionError("Discovery must not compile"); }
});
try {
Path root = project("alternate", id, "1", "[]");
access.register(root, () -> () -> {}, () -> true);
var result = knowledge().context(root);
assertSupport(result.languages().getFirst(), "lsp", ProjectKnowledge.Support.UNKNOWN);
assertTrue(result.limitations().stream().anyMatch(value -> value.contains("cannot describe LSP")));
} finally { FrontendRegistryService.unregister(id); }
}
private Path project(String name, String language, String sdk, String dependencies) throws Exception {
Path root = Files.createDirectories(directory.resolve(name)).toRealPath();
var manifest = mapper.createObjectNode().put("name", name).put("version", "1.0.0")
.put("language", language).put("stdlib", sdk).put("target", "Game");
manifest.set("dependencies", mapper.readTree(dependencies));
mapper.writeValue(root.resolve("prometeu.json").toFile(), manifest);
return root;
}
private ProjectKnowledge.Library library(ProjectKnowledge.Context context, Path root) {
return context.libraries().stream().filter(library -> library.roots().contains(root)).findFirst().orElseThrow();
}
private void assertSupport(ProjectKnowledge.Language language, String name, ProjectKnowledge.Support support) {
assertEquals(support, language.capabilities().stream().filter(capability -> capability.name().equals(name)).findFirst().orElseThrow().support());
}
}