expose manifest-driven project knowledge through MCP
This commit is contained in:
@@ -29,7 +29,9 @@ class StudioApplicationConfigurationTest {
|
||||
assertFalse(context.getClass().getName().contains("WebServer"));
|
||||
assertFalse(executor.isShutdown());
|
||||
assertTrue(mcp.isRunning());
|
||||
assertTrue(context.getBean(p.studio.app.mcp.McpToolRegistry.class).descriptors().isEmpty());
|
||||
var tools = context.getBean(p.studio.app.mcp.McpToolRegistry.class).descriptors();
|
||||
org.junit.jupiter.api.Assertions.assertEquals(1, tools.size());
|
||||
org.junit.jupiter.api.Assertions.assertEquals("studio_project_context", tools.get(0).path("name").asText());
|
||||
}
|
||||
assertTrue(executor.isShutdown());
|
||||
assertFalse(mcp.isRunning());
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -103,6 +103,38 @@ class LocalMcpServerTest {
|
||||
assertTrue(result.path("isError").asBoolean()); assertEquals("NOT_GRANTED", result.path("structuredContent").path("error").path("code").asText());
|
||||
}
|
||||
|
||||
@Test void realContextHandlerReadsAnOpenProjectWithoutGrantAndRejectsItAfterClose(
|
||||
@org.junit.jupiter.api.io.TempDir java.nio.file.Path temporary) throws Exception {
|
||||
var root = temporary.toRealPath();
|
||||
java.nio.file.Files.writeString(root.resolve("prometeu.json"), """
|
||||
{"name":"HTTP context","version":"1.0.0","language":"pbs","stdlib":"1","target":"Game","dependencies":[]}
|
||||
""");
|
||||
var open = new p.studio.core.project.ProjectAccessRegistry();
|
||||
var registration = open.register(root, () -> { throw new AssertionError("Context must not acquire manual control"); }, () -> true);
|
||||
var catalog = new p.studio.core.project.ProjectCatalogService(root, mapper,
|
||||
new p.studio.core.project.ProjectLocalStudioSetupStore(mapper));
|
||||
var knowledge = new p.studio.app.compiler.CompilerProjectKnowledge(open, catalog, mapper);
|
||||
server.close();
|
||||
server = new LocalMcpServer(mapper, new McpToolRegistry(new McpToolCatalog(mapper), mapper,
|
||||
McpProjectKnowledgeTools.handlers(knowledge, mapper)));
|
||||
server.start();
|
||||
initialize();
|
||||
var call = mapper.createObjectNode().put("jsonrpc", "2.0").put("id", 2).put("method", "tools/call");
|
||||
call.putObject("params").put("name", "studio_project_context").putObject("arguments").put("projectRoot", root.toString());
|
||||
var wire = mapper.readTree(post(call.toString()).body()).path("result");
|
||||
assertFalse(wire.path("isError").asBoolean());
|
||||
var value = wire.path("structuredContent").path("value");
|
||||
assertEquals(root.toString(), value.path("projectRoot").asText());
|
||||
assertEquals(root.toString(), value.path("editableRoots").get(0).asText());
|
||||
assertEquals("pbs", value.path("languages").get(0).path("id").asText());
|
||||
assertTrue(value.path("languages").get(0).path("languageVersion").path("value").isNull());
|
||||
assertFalse(java.nio.file.Files.exists(root.resolve(".studio")));
|
||||
registration.unsubscribe();
|
||||
var denied = mapper.readTree(post(call.toString()).body()).path("result");
|
||||
assertTrue(denied.path("isError").asBoolean());
|
||||
assertEquals("PROJECT_NOT_OPEN", denied.path("structuredContent").path("error").path("code").asText());
|
||||
}
|
||||
|
||||
@Test void hostileHostAndDuplicateOriginAreRejectedEvenWithValidCredentials() throws Exception {
|
||||
var connection = server.connection();
|
||||
try (var socket = new java.net.Socket("127.0.0.1", connection.endpoint().getPort())) {
|
||||
|
||||
Reference in New Issue
Block a user