feat: resolve and parse elide project manifest

darvld · darvld · commit acf37b469bad · 2025-06-30T18:55:45.000-04:00
Signed-off-by: Dario Valdespino &lt;dvaldespino00@gmail.com&gt;
diff --git a/packages/plugin-idea/build.gradle.kts b/packages/plugin-idea/build.gradle.kts
@@ -14,17 +14,20 @@
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
-  id("java")
   alias(libs.plugins.elide.conventions)
   alias(libs.plugins.intellij.platform)
   kotlin("jvm")
+  id("java")
 }
 
 elide {
   jvm {
     // Intellij plugins can only target up to JVM 21
     target = JvmTarget.JVM_21
   }
+  kotlin {
+    customKotlinCompilerArgs += "-Xskip-prerelease-check"
+  }
 }
 
 repositories {
diff --git a/packages/plugin-idea/src/main/kotlin/dev/elide/intellij/Constants.kt b/packages/plugin-idea/src/main/kotlin/dev/elide/intellij/Constants.kt
@@ -13,19 +13,25 @@
 
 package dev.elide.intellij
 
+import com.intellij.DynamicBundle
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.externalSystem.model.ProjectSystemId
 import com.intellij.openapi.fileChooser.FileChooserDescriptor
 import com.intellij.openapi.util.IconLoader
 import com.intellij.ui.IconManager
 import com.intellij.ui.PlatformIcons
+import dev.elide.intellij.Constants.Strings.get
+import org.jetbrains.annotations.PropertyKey
 import javax.swing.Icon
 
 /** Useful constants used by the Elide plugin. */
 object Constants {
   /** External System ID for Elide. */
   val SYSTEM_ID = ProjectSystemId("ELIDE")
 
+  /** Elide plugin ID. */
+  const val PLUGIN_ID = "dev.elide.intellij"
+
   /** ID used to reference settings panels. */
   const val CONFIGURABLE_ID = "reference.settingsdialog.project.elide"
 
@@ -69,4 +75,14 @@ object Constants {
       }
     }
   }
+
+  /**
+   * Localized strings provided by a resource bundle, use the indexing operator or the static [get] function to obtain
+   * formatted messages.
+   */
+  data object Strings : DynamicBundle("i18n.Strings") {
+    @JvmStatic operator fun get(@PropertyKey(resourceBundle = "i18n.Strings") key: String, vararg params: Any): String {
+      return getMessage(key, params = params)
+    }
+  }
 }
diff --git a/packages/plugin-idea/src/main/kotlin/dev/elide/intellij/ElideManager.kt b/packages/plugin-idea/src/main/kotlin/dev/elide/intellij/ElideManager.kt
@@ -14,7 +14,9 @@
 package dev.elide.intellij
 
 import com.intellij.execution.configurations.SimpleJavaParameters
+import com.intellij.ide.plugins.PluginManagerCore
 import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.extensions.PluginId
 import com.intellij.openapi.externalSystem.ExternalSystemAutoImportAware
 import com.intellij.openapi.externalSystem.ExternalSystemManager
 import com.intellij.openapi.externalSystem.model.ProjectSystemId
@@ -28,6 +30,7 @@ import dev.elide.intellij.project.ElideProjectResolver
 import dev.elide.intellij.settings.*
 import dev.elide.intellij.tasks.ElideTaskManager
 import java.io.File
+import kotlin.io.path.*
 
 /**
  * Coordinator service for Elide as an external build system.
@@ -83,7 +86,27 @@ class ElideManager : ExternalSystemAutoImportAware, ExternalSystemManager<
   override fun getExternalProjectDescriptor(): FileChooserDescriptor = Constants.projectFileChooser()
 
   override fun enhanceRemoteProcessing(params: SimpleJavaParameters) {
-    // noop
+    // the project resolver runs in a separate process, but it needs access to many plugin dependencies;
+    // to avoid class loading issues, we enhance its classpath with all JARs in the plugin's 'lib' path
+    try {
+      val plugin = PluginManagerCore.getPlugin(PluginId.getId(Constants.PLUGIN_ID))
+      if (plugin == null) {
+        LOG.warn("Cannot find plugin ${Constants.PLUGIN_ID}")
+        return
+      }
+
+      val pluginPath = plugin.pluginPath
+      LOG.info("Enhancing remote process classpath from: $pluginPath")
+
+      pluginPath.resolve("lib").takeIf { it.exists() && it.isDirectory() }?.useDirectoryEntries { entries ->
+        entries.filter { it.isRegularFile() && it.extension == "jar" }.forEach { entry ->
+          params.classPath.add(entry.toString())
+          LOG.debug("Added remote classpath entry: $entry")
+        }
+      }
+    } catch (e: Exception) {
+      LOG.error("Failed to enhance remote processing, project resolver will not work", e)
+    }
   }
 
   override fun getAffectedExternalProjectPath(changedFileOrDirPath: String, project: Project): String? {
diff --git a/packages/plugin-idea/src/main/kotlin/dev/elide/intellij/manifests/ElideManifestService.kt b/packages/plugin-idea/src/main/kotlin/dev/elide/intellij/manifests/ElideManifestService.kt
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2024-2025 Elide Technologies, Inc.
+ *
+ * Licensed under the MIT license (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   https://opensource.org/license/mit/
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under the License.
+ */
+
+package dev.elide.intellij.manifests
+
+import java.io.InputStream
+import java.io.OutputStream
+import java.nio.file.Path
+import elide.tooling.project.PackageManifestService
+import elide.tooling.project.ProjectEcosystem
+import elide.tooling.project.codecs.ElidePackageManifestCodec
+import elide.tooling.project.manifest.ElidePackageManifest
+import elide.tooling.project.manifest.PackageManifest
+
+/** Basic manifest service that only resolves Elide manifests. */
+class ElideManifestService : PackageManifestService {
+  private val elideCodec = ElidePackageManifestCodec()
+
+  private fun ProjectEcosystem.requireElide() {
+    require(this == ProjectEcosystem.Elide) { "Only Elide package manifests are supported for resolution" }
+  }
+
+  override fun resolve(root: Path, ecosystem: ProjectEcosystem): Path {
+    ecosystem.requireElide()
+    return root.resolve(elideCodec.defaultPath())
+  }
+
+  override fun parse(source: Path): ElidePackageManifest {
+    return elideCodec.parseAsFile(source)
+  }
+
+  override fun parse(source: InputStream, ecosystem: ProjectEcosystem): ElidePackageManifest {
+    ecosystem.requireElide()
+    return elideCodec.parse(source)
+  }
+
+  override fun merge(manifests: Iterable<PackageManifest>): ElidePackageManifest {
+    throw UnsupportedOperationException()
+  }
+
+  override fun export(manifest: ElidePackageManifest, ecosystem: ProjectEcosystem): PackageManifest {
+    throw UnsupportedOperationException()
+  }
+
+  override fun encode(manifest: PackageManifest, output: OutputStream) {
+    require(manifest is ElidePackageManifest) { "Only Elide package manifests are supported" }
+    elideCodec.write(manifest, output)
+  }
+}
diff --git a/packages/plugin-idea/src/main/kotlin/dev/elide/intellij/project/ElideProjectAware.kt b/packages/plugin-idea/src/main/kotlin/dev/elide/intellij/project/ElideProjectAware.kt
@@ -18,19 +18,27 @@ import com.intellij.openapi.externalSystem.autoimport.ExternalSystemProjectAware
 import com.intellij.openapi.externalSystem.autoimport.ExternalSystemProjectId
 import com.intellij.openapi.externalSystem.autoimport.ExternalSystemProjectListener
 import com.intellij.openapi.externalSystem.autoimport.ExternalSystemProjectReloadContext
+import com.intellij.openapi.externalSystem.service.execution.ProgressExecutionMode
+import com.intellij.openapi.externalSystem.util.ExternalSystemUtil
 import com.intellij.openapi.project.Project
 import dev.elide.intellij.Constants
 
 /** A tracker for a project in the current IDE instance, used to trigger auto-import and sync operations. */
-class ElideProjectAware(private val project: Project, projectPath: String) : ExternalSystemProjectAware {
+class ElideProjectAware(private val project: Project, private val projectPath: String) : ExternalSystemProjectAware {
   override val projectId: ExternalSystemProjectId = ExternalSystemProjectId(Constants.SYSTEM_ID, projectPath)
   override val settingsFiles: Set<String> = setOf("$projectPath/${Constants.MANIFEST_NAME}")
 
   override fun subscribe(listener: ExternalSystemProjectListener, parentDisposable: Disposable) {
-    // notify the listener once project sync is complete
+    // TODO: notify the listener about project sync status
   }
 
   override fun reloadProject(context: ExternalSystemProjectReloadContext) {
-    // noop
+    ExternalSystemUtil.refreshProject(
+      /* project = */ project,
+      /* externalSystemId = */ Constants.SYSTEM_ID,
+      /* externalProjectPath = */ projectPath,
+      /* isPreviewMode = */ false,
+      /* progressExecutionMode = */ ProgressExecutionMode.IN_BACKGROUND_ASYNC,
+    )
   }
 }
diff --git a/packages/plugin-idea/src/main/kotlin/dev/elide/intellij/project/ElideProjectResolver.kt b/packages/plugin-idea/src/main/kotlin/dev/elide/intellij/project/ElideProjectResolver.kt
@@ -21,10 +21,22 @@ import com.intellij.openapi.externalSystem.model.project.ExternalSystemSourceTyp
 import com.intellij.openapi.externalSystem.model.project.ModuleData
 import com.intellij.openapi.externalSystem.model.project.ProjectData
 import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId
+import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskNotificationEvent
 import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskNotificationListener
 import com.intellij.openapi.externalSystem.service.project.ExternalSystemProjectResolver
 import dev.elide.intellij.Constants
+import dev.elide.intellij.manifests.ElideManifestService
 import dev.elide.intellij.settings.ElideExecutionSettings
+import java.nio.file.Path
+import kotlinx.coroutines.runBlocking
+import kotlin.io.path.Path
+import kotlin.io.path.notExists
+import elide.tooling.lockfile.LockfileLoader
+import elide.tooling.lockfile.loadLockfileSafe
+import elide.tooling.project.ElideConfiguredProject
+import elide.tooling.project.ElideProjectInfo
+import elide.tooling.project.ElideProjectLoader
+import elide.tooling.project.SourceSetFactory
 
 /**
  * A service capable of using the Elide manifest and lockfile to build a project model that can be understood by the
@@ -35,33 +47,81 @@ import dev.elide.intellij.settings.ElideExecutionSettings
  * tracker.
  */
 class ElideProjectResolver : ExternalSystemProjectResolver<ElideExecutionSettings> {
-  override fun cancelTask(id: ExternalSystemTaskId, listener: ExternalSystemTaskNotificationListener): Boolean = true
+  /** Shortcut to emit a status change event with the given description [text]. */
+  private fun ExternalSystemTaskNotificationListener.onStep(taskId: ExternalSystemTaskId, text: String) {
+    val event = ExternalSystemTaskNotificationEvent(taskId, text)
+    onStatusChange(event)
+  }
+
+  override fun cancelTask(id: ExternalSystemTaskId, listener: ExternalSystemTaskNotificationListener): Boolean {
+    return true
+  }
 
   override fun resolveProjectInfo(
     id: ExternalSystemTaskId,
     projectPath: String,
     isPreviewMode: Boolean,
     settings: ElideExecutionSettings?,
     listener: ExternalSystemTaskNotificationListener
-  ): DataNode<ProjectData?>? {
+  ): DataNode<ProjectData>? {
     LOG.debug("Resolving project at '$projectPath'")
+    listener.onStart(projectPath, id)
+    val projectModel = runCatching {
+      // find a manifest in the project directory
+      listener.onStep(id, Constants.Strings["resolve.steps.discovery"])
+      val projectRoot = Path(projectPath)
+      val manifestPath = projectRoot.resolve(Constants.MANIFEST_NAME)
+
+      if (manifestPath.notExists()) {
+        LOG.debug("No Elide manifest found under $projectPath")
+        return@runCatching null
+      }
+
+      // parse the manifest
+      listener.onStep(id, Constants.Strings["resolve.steps.parse"])
+      val manifest = ElideManifestService().parse(manifestPath)
 
+      // call the CLI in case the lockfile is outdated
+      // listener.onStep(id, Constants.Strings["resolve.steps.sync"])
+      // TODO: launch sync task in the background and wait for it here
+
+      // configure the project
+      listener.onStep(id, Constants.Strings["resolve.steps.configure"])
+      val loader = buildProjectLoader(projectRoot, settings)
+      val project = runBlocking { ElideProjectInfo(projectRoot, manifest, null).load(loader) }
+
+      // build the project model from the manifest and lockfile
+      listener.onStep(id, Constants.Strings["resolve.steps.buildModel"])
+      buildProjectModel(projectPath, project)
+    }.onSuccess {
+      listener.onSuccess(projectPath, id)
+    }.onFailure { cause ->
+      listener.onTaskOutput(id, "Failed to sync project: $cause", false)
+      listener.onFailure(projectPath, id, RuntimeException(cause))
+    }
+
+    listener.onEnd(projectPath, id)
+    return projectModel.getOrThrow()
+  }
+
+  /** Build the project model given a configured Elide [project]. */
+  private fun buildProjectModel(projectPath: String, project: ElideConfiguredProject): DataNode<ProjectData> {
     // stubbed project model
     val projectData = ProjectData(
-      Constants.SYSTEM_ID,
-      "Elide Project",
-      projectPath,
-      projectPath,
+      /* owner = */ Constants.SYSTEM_ID,
+      /* externalName = */ project.manifest.name ?: Constants.Strings["project.defaults.name"],
+      /* ideProjectFileDirectoryPath = */ projectPath,
+      /* linkedExternalProjectPath = */ projectPath,
     )
 
-    // stubbed sample module
+    // main project module
     val module = ModuleData(
-      "sample",
-      Constants.SYSTEM_ID,
-      "JAVA_MODULE",
-      "Sample",
-      "$projectPath/src/main",
-      "$projectPath/src/main",
+      /* id = */ "main",
+      /* owner = */ Constants.SYSTEM_ID,
+      /* moduleTypeId = */ "JAVA_MODULE",
+      /* externalName = */ "main",
+      /* moduleFileDirectoryPath = */ "$projectPath/src/main",
+      /* externalConfigPath = */ "$projectPath/src/main",
     )
 
     val projectNode = DataNode(ProjectKeys.PROJECT, projectData, null)
@@ -79,6 +139,20 @@ class ElideProjectResolver : ExternalSystemProjectResolver<ElideExecutionSetting
     return projectNode
   }
 
+  /**
+   * Construct a new [ElideProjectLoader] that uses the resources from the Elide distribution set in the execution
+   * [settings].
+   */
+  private fun buildProjectLoader(projectPath: Path, settings: ElideExecutionSettings?): ElideProjectLoader {
+    return object : ElideProjectLoader {
+      override val lockfileLoader: LockfileLoader = LockfileLoader { loadLockfileSafe(projectPath) }
+      override val sourceSetFactory: SourceSetFactory = SourceSetFactory.Default
+
+      // TODO(@darvld): resolve from execution settings
+      override val resourcesPath: Path get() = projectPath.resolve(".elide")
+    }
+  }
+
   private companion object {
     @JvmStatic private val LOG = Logger.getInstance(ElideProjectResolver::class.java)
   }
diff --git a/packages/plugin-idea/src/main/resources/META-INF/plugin.xml b/packages/plugin-idea/src/main/resources/META-INF/plugin.xml
@@ -26,7 +26,7 @@
   <extensions defaultExtensionNs="com.intellij">
     <externalIconProvider key="ELIDE" implementationClass="dev.elide.intellij.ui.ElideIconProvider"/>
     <postStartupActivity implementation="dev.elide.intellij.startup.ElideStartupSyncActivity"/>
-    <externalSystemManager implementation="dev.elide.intellij.ElideManager"/>
+    <externalSystemManager id="ELIDE" implementation="dev.elide.intellij.ElideManager"/>
     <projectConfigurable
             key="elide"
             id="reference.settingsdialog.project.elide"
diff --git a/packages/plugin-idea/src/main/resources/i18n/Strings.properties b/packages/plugin-idea/src/main/resources/i18n/Strings.properties
@@ -12,3 +12,14 @@
 #
 
 elide=Elide
+
+# project resolution messages
+resolve.steps.discovery=Searching for an Elide project manifest
+resolve.steps.parse=Parsing Elide project manifest
+resolve.steps.configure=Configuring Elide project
+resolve.steps.buildModel=Building Elide project model
+resolve.steps.install=Installing project dependencies
+resolve.steps.sync=Syncing Elide project
+
+# project model defaults
+project.defaults.name=Elide Project

Original file line number	Diff line number	Diff line change
`@@ -14,17 +14,20 @@`
`14`	`14`	`import org.jetbrains.kotlin.gradle.dsl.JvmTarget`
`15`	`15`
`16`	`16`	`plugins {`
`17`		`- id("java")`
`18`	`17`	`alias(libs.plugins.elide.conventions)`
`19`	`18`	`alias(libs.plugins.intellij.platform)`
`20`	`19`	`kotlin("jvm")`
	`20`	`+ id("java")`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`elide {`
`24`	`24`	`jvm {`
`25`	`25`	`// Intellij plugins can only target up to JVM 21`
`26`	`26`	`target = JvmTarget.JVM_21`
`27`	`27`	`}`
	`28`	`+ kotlin {`
	`29`	`+ customKotlinCompilerArgs += "-Xskip-prerelease-check"`
	`30`	`+ }`
`28`	`31`	`}`
`29`	`32`
`30`	`33`	`repositories {`