package p.studio.app.compiler; import com.fasterxml.jackson.databind.ObjectMapper; import p.studio.api.automation.AutomationException; import p.studio.api.automation.AutomationFailure; import p.studio.api.automation.ProjectKnowledge; import p.studio.api.project.ProjectCatalog; import p.studio.api.project.ProjectReference; import p.studio.compiler.FrontendRegistryService; import p.studio.compiler.dtos.PrometeuManifestDTO; import p.studio.compiler.messages.BuildingIssueSink; import p.studio.compiler.workspaces.phases.DependencyResolver; import p.studio.core.project.ProjectAccessRegistry; import p.studio.lsp.messages.LspProjectContext; import p.studio.lsp.services.compiler.CompilerLanguageServiceBridge; import java.io.IOException; import java.nio.file.Path; import java.util.*; /** Read-only manifest/provider discovery. Never selects a default frontend or starts a build. */ public final class CompilerProjectKnowledge implements ProjectKnowledge { private record OwnedReference(String owner, p.studio.compiler.services.FrontendReferenceProvider.Reference reference) {} private record Discovery(Context context, Map references) {} private static final int MAX_PROJECTS = 256; private final ProjectAccessRegistry openProjects; private final ProjectCatalog projects; private final ObjectMapper mapper; private final CompilerLanguageServiceBridge languageBridge; public CompilerProjectKnowledge(ProjectAccessRegistry openProjects, ProjectCatalog projects, ObjectMapper mapper) { this(openProjects,projects,mapper,null); } public CompilerProjectKnowledge(ProjectAccessRegistry openProjects,ProjectCatalog projects,ObjectMapper mapper,p.animation.GlyphBankLayoutSource layouts) { this.languageBridge=new CompilerLanguageServiceBridge(layouts); this.openProjects = Objects.requireNonNull(openProjects); this.projects = Objects.requireNonNull(projects); this.mapper = Objects.requireNonNull(mapper); } @Override public Context context(Path openProjectRoot) { return discover(openProjectRoot).context(); } private Discovery discover(Path openProjectRoot) { Path root = openProjects.requireOpenRoot(openProjectRoot); var limitations = new ArrayList(); var discovered = new LinkedHashMap(); var dependencies = new LinkedHashMap>(); var readOnly = new LinkedHashSet(); var unresolved = new ArrayList(); var pending = new ArrayDeque(); var visited = new HashSet(); pending.add(root); boolean dependenciesComplete = true; while (!pending.isEmpty()) { Path current = pending.removeFirst(); if (!visited.add(current)) continue; if (visited.size() > MAX_PROJECTS) throw new AutomationException(AutomationFailure.Code.LIMIT_EXCEEDED, "Project graph exceeds " + MAX_PROJECTS + " projects"); ProjectReference project; PrometeuManifestDTO manifest; try { project = projects.openProject(current); manifest = mapper.readValue(current.resolve("prometeu.json").toFile(), PrometeuManifestDTO.class); } catch (IOException | RuntimeException failure) { if (current.equals(root)) throw new AutomationException(AutomationFailure.Code.INFRASTRUCTURE_FAILURE, "Cannot read the current project manifest"); dependenciesComplete = false; limitations.add("Dependency manifest unavailable: " + current); unresolved.add(new Library(current.toString(), Version.unknown(), List.of(current), false)); readOnly.add(current); dependencies.put(current, List.of()); continue; } discovered.put(current, project); var children = new ArrayList(); dependencies.put(current, children); if (manifest.dependencies() == null) continue; if (manifest.dependencies().size() > MAX_PROJECTS) throw new AutomationException(AutomationFailure.Code.LIMIT_EXCEEDED, "Too many dependency declarations"); for (var declaration : manifest.dependencies()) { if (declaration == null || declaration instanceof PrometeuManifestDTO.DependencyDeclaration.Local local && (local.path() == null || local.path().isBlank()) || declaration instanceof PrometeuManifestDTO.DependencyDeclaration.Registry registry && (registry.name() == null || registry.name().isBlank() || registry.version() == null || registry.version().isBlank())) throw new AutomationException(AutomationFailure.Code.INFRASTRUCTURE_FAILURE, "Invalid dependency declaration in " + current); var issues = BuildingIssueSink.empty(); // The compiler resolves even transitive local paths and registry entries against the main root. var resolved = DependencyResolver.resolveDependencies(root, List.of(declaration), issues); if (issues.hasErrors() || resolved.isEmpty()) { dependenciesComplete = false; String id = declaration instanceof PrometeuManifestDTO.DependencyDeclaration.Registry registry ? registry.name() + "@" + registry.version() : String.valueOf(((PrometeuManifestDTO.DependencyDeclaration.Local) declaration).path()); var version = declaration instanceof PrometeuManifestDTO.DependencyDeclaration.Registry registry && registry.version() != null && !registry.version().isBlank() ? new Version(registry.version(), current.resolve("prometeu.json") + "#dependencies (requested)") : Version.unknown(); unresolved.add(new Library(id, version, List.of(), false)); limitations.add("Dependency could not be resolved by the compiler: " + id + " (declared by " + current + ")"); continue; } Path child = resolved.getFirst().canonPath(); children.add(child); if (!child.startsWith(root) || declaration instanceof PrometeuManifestDTO.DependencyDeclaration.Registry) readOnly.add(child); pending.add(child); } } // Read-only provenance wins if a library is reachable through more than one declaration. boolean changed; do { changed = false; for (var edge : dependencies.entrySet()) if (readOnly.stream().anyMatch(edge.getKey()::startsWith)) changed |= readOnly.addAll(edge.getValue()); } while (changed); var protectedSources = new LinkedHashSet(); for (var project : discovered.values()) { if (readOnly.stream().anyMatch(project.rootPath()::startsWith)) FrontendRegistryService.getProvider(project.languageId()).ifPresent(provider -> provider.specification().getSourceRoots().forEach(relative -> protectedSources.add(canonical(project.rootPath().resolve(relative))))); } readOnly.addAll(protectedSources); var libraries = new ArrayList(); var byLanguage = new LinkedHashMap>(); for (var entry : discovered.entrySet()) { var project = entry.getValue(); byLanguage.computeIfAbsent(project.languageId(), ignored -> new ArrayList<>()).add(project); if (!entry.getKey().equals(root)) { boolean editable = entry.getKey().startsWith(root) && readOnly.stream().noneMatch(entry.getKey()::startsWith); libraries.add(new Library(project.name(), new Version(project.version(), entry.getKey().resolve("prometeu.json") + "#version"), List.of(entry.getKey()), editable)); } } libraries.addAll(unresolved); var references = new LinkedHashMap(); discovered.values().forEach(project -> collectReferences(project, references, limitations)); var languages = new ArrayList(); String primary = discovered.get(root).languageId(); if (byLanguage.size() > 1) limitations.add("The installed build pipeline requires the same language across the dependency graph"); for (var entry : byLanguage.entrySet()) { var language = language(entry.getKey(), entry.getValue(), primary.equals(entry.getKey()), dependenciesComplete && byLanguage.size() == 1, limitations, references.entrySet().stream().filter(ref -> ref.getValue().owner().equals(entry.getKey())).map(Map.Entry::getKey).toList()); languages.add(language); for (Path source : language.sourceRoots()) if (!source.startsWith(root)) readOnly.add(source); for (var project : entry.getValue()) { var sdk = new Library("sdk:" + entry.getKey() + ":" + project.stdlibVersion(), new Version(Integer.toString(project.stdlibVersion()), project.rootPath().resolve("prometeu.json") + "#stdlib (requested)"), List.of(), false); if (libraries.stream().noneMatch(item -> item.id().equals(sdk.id()))) libraries.add(sdk); } } limitations.add("SDK resources are provider-owned, read-only resources, not editable project files"); limitations.add("Virtual SDK symbols may have no physical LSP definition location; consult indexed SDK references"); // Closing a project during discovery must not publish a successful context for that closed project. openProjects.requireOpenRoot(root); var descriptors = references.values().stream().map(owned -> { var ref = owned.reference(); return new Reference(ref.id(), ref.title(), owned.owner(), ReferenceKind.valueOf(ref.kind().name()), new Version(ref.version(), ref.versionSource())); }).toList(); return new Discovery(new Context(root, discovered.get(root).name(), languages, libraries, List.of(root), List.copyOf(readOnly), descriptors, limitations.stream().distinct().toList()), Map.copyOf(references)); } private Language language(String id, List projects, boolean primary, boolean graphBuildable, List limitations, List referenceIds) { var sdkVersions = projects.stream().map(ProjectReference::stdlibVersion).distinct().toList(); Version sdk = sdkVersions.size() == 1 ? new Version(sdkVersions.getFirst().toString(), "prometeu.json#stdlib (requested)") : Version.unknown(); if (sdkVersions.size() != 1) limitations.add("Multiple SDK versions requested for " + id + ": " + sdkVersions); var provider = FrontendRegistryService.getProvider(id); if (provider.isEmpty()) { limitations.add("UNSUPPORTED_LANGUAGE: no installed frontend for " + id); return new Language(id, primary, Version.unknown(), Version.unknown(), sdk, List.of(), List.of(), List.of(capability("build", false), capability("lsp", false)), referenceIds); } var spec = provider.get().specification(); var roots = new LinkedHashSet(); projects.forEach(project -> spec.getSourceRoots().forEach(relative -> roots.add(canonical(project.rootPath().resolve(relative))))); boolean sdkSupported = sdkVersions.stream().allMatch(version -> spec.getStdlibVersions().stream().anyMatch(item -> item.version() == version)); if (!sdkSupported) limitations.add("Unsupported requested SDK version for " + id + ": " + sdkVersions); if (sdkSupported && sdk.known()) sdk = new Version(sdk.value(), "prometeu.json#stdlib; supported by installed frontend"); var capabilities = new ArrayList(); capabilities.add(capability("build", graphBuildable && sdkSupported)); var project = projects.getFirst(); addLspCapabilities(id, project, capabilities, limitations); String compilerVersion = provider.get().getClass().getPackage().getImplementationVersion(); return new Language(id, primary, Version.unknown(), compilerVersion == null || compilerVersion.isBlank() ? Version.unknown() : new Version(compilerVersion, "installed frontend package Implementation-Version"), sdk, spec.getAllowedExtensions().stream().sorted().toList(), List.copyOf(roots), capabilities, referenceIds); } private void collectReferences(ProjectReference project, Map references, List limitations) { String owner = project.languageId(); String selection = owner + " / " + project.target() + " / SDK " + project.stdlibVersion(); try { var documentation = FrontendRegistryService.getProvider(owner).flatMap(p.studio.compiler.services.FrontendProvider::documentation); if (documentation.isEmpty()) { limitations.add("DOCUMENTATION_UNAVAILABLE: no installed reference provider for " + owner); return; } var selected = documentation.get().references(project.stdlibVersion(), p.studio.AppMode.valueOf(project.target().name())); var additions = new LinkedHashMap(); for (var reference : selected) { var owned = new OwnedReference(owner, reference); if (!reference.id().startsWith(owner + ":") || references.containsKey(reference.id()) && !references.get(reference.id()).equals(owned) || additions.putIfAbsent(reference.id(), owned) != null) throw new IllegalStateException("Ambiguous or invalid reference ID"); } references.putAll(additions); if (selected.isEmpty()) limitations.add("DOCUMENTATION_UNAVAILABLE: no installed references for " + selection); if (selected.stream().noneMatch(ref -> ref.kind() == p.studio.compiler.services.FrontendReferenceProvider.Kind.SDK && Integer.toString(project.stdlibVersion()).equals(ref.version()))) limitations.add("DOCUMENTATION_UNAVAILABLE: no installed SDK reference for " + selection); } catch (RuntimeException unavailable) { limitations.add("DOCUMENTATION_UNAVAILABLE: cannot load installed references for " + selection); } } private void addLspCapabilities(String id, ProjectReference project, List capabilities, List limitations) { final p.studio.lsp.messages.BaselineServerDescription server; try { server = languageBridge.describeServer(new LspProjectContext(project.rootPath().toString(), id, project.rootPath())); } catch (RuntimeException unavailable) { String reason = "Installed frontend cannot describe LSP capabilities for " + id; capabilities.add(new Capability("lsp", Support.UNKNOWN, reason)); limitations.add(reason); return; } capabilities.add(capability("lsp", true)); capabilities.add(capability("diagnostics", true)); capabilities.add(capability("semanticTokens", true)); capabilities.add(capability("hover", server.hoverSupported())); capabilities.add(capability("completion", server.completionSupported())); capabilities.add(capability("signatureHelp", server.signatureHelpSupported())); capabilities.add(capability("definition", server.definitionSupported())); capabilities.add(capability("references", server.referencesSupported())); capabilities.add(capability("documentSymbols", server.documentSymbolsSupported())); capabilities.add(capability("workspaceSymbols", server.workspaceSymbolsSupported())); capabilities.add(capability("rename", server.renameSupported())); capabilities.add(capability("codeActions", server.codeActionsSupported())); capabilities.add(capability("documentLinks", server.documentLinksSupported())); capabilities.add(capability("foldingRanges", server.foldingRangesSupported())); capabilities.add(capability("selectionRanges", server.selectionRangesSupported())); capabilities.add(capability("formatting", server.formattingSupported())); capabilities.add(capability("callHierarchy", server.callHierarchySupported())); capabilities.add(capability("typeHierarchy", false)); } private static Capability capability(String name, boolean supported) { return new Capability(name, supported ? Support.SUPPORTED : Support.UNSUPPORTED, supported ? null : "Not supported by the installed provider or current project dependency/SDK configuration"); } private static Path canonical(Path path) { Path normalized = path.toAbsolutePath().normalize(); try { return normalized.toRealPath(); } catch (IOException ignored) { Path parent = normalized.getParent(); return parent == null ? normalized : canonical(parent).resolve(normalized.getFileName()); } } @Override public ReferencePage readReference(Path openProjectRoot, String referenceId, int offset, int limit) { openProjects.requireOpenRoot(openProjectRoot); if (referenceId == null || referenceId.isBlank() || offset < 0 || limit < 1 || limit > 16000) throw new IllegalArgumentException("Invalid reference ID or pagination"); var discovery = discover(openProjectRoot); var reference = discovery.references().get(referenceId); if (reference == null) { var primary = discovery.context().languages().stream().filter(Language::primary).findFirst().orElseThrow(); var code = FrontendRegistryService.getProvider(primary.id()).isEmpty() ? AutomationFailure.Code.UNSUPPORTED_LANGUAGE : discovery.references().isEmpty() ? AutomationFailure.Code.DOCUMENTATION_UNAVAILABLE : AutomationFailure.Code.REFERENCE_NOT_FOUND; throw new AutomationException(code, "Reference is not available in this project's installed index"); } String text = reference.reference().text(); int total = text.codePointCount(0, text.length()); if (offset > total) throw new IllegalArgumentException("Reference offset exceeds its length"); int next = offset + Math.min(limit, total - offset); String page = text.substring(text.offsetByCodePoints(0, offset), text.offsetByCodePoints(0, next)); return new ReferencePage(referenceId, offset, total, next == total ? null : next, page); } }