chore(idea): refactor project sync components

Signed-off-by: Dario Valdespino <dvaldespino00@gmail.com>

Author: darvld

packages/plugin-idea/src/main/kotlin/dev/elide/intellij/project/ElideProjectAware.kt

@@ -0,0 +1,66 @@
+/*
+ * 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.project
+
+import com.intellij.openapi.application.EDT
+import com.intellij.openapi.externalSystem.action.DetachExternalProjectAction
+import com.intellij.openapi.externalSystem.importing.AbstractOpenProjectProvider
+import com.intellij.openapi.externalSystem.model.ProjectSystemId
+import com.intellij.openapi.externalSystem.service.execution.ProgressExecutionMode
+import com.intellij.openapi.externalSystem.service.project.trusted.ExternalSystemTrustedProjectDialog
+import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
+import com.intellij.openapi.externalSystem.util.ExternalSystemUtil
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.io.toCanonicalPath
+import com.intellij.openapi.vfs.VirtualFile
+import dev.elide.intellij.Constants
+import dev.elide.intellij.settings.ElideProjectSettings
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+/** Service used to link an Elide project with the IDE, enabling auto-import, sync, and other features. */
+@Suppress("UnstableApiUsage") class ElideOpenProjectProvider : AbstractOpenProjectProvider() {
+  override val systemId: ProjectSystemId = Constants.SYSTEM_ID
+
+  override fun isProjectFile(file: VirtualFile): Boolean = !file.isDirectory && file.name == Constants.MANIFEST_NAME
+
+  override suspend fun linkProject(projectFile: VirtualFile, project: Project) {
+    val projectPath = getProjectDirectory(projectFile).toNioPath()
+    if (!ExternalSystemTrustedProjectDialog.confirmLinkingUntrustedProjectAsync(
+        project = project,
+        systemId = Constants.SYSTEM_ID,
+        projectRoot = projectPath,
+      )
+    ) return
+
+    val settings = ElideProjectSettings()
+    settings.externalProjectPath = projectPath.toCanonicalPath()
+
+    ExternalSystemUtil.linkExternalProject(
+      /* externalSystemId = */ systemId,
+      /* projectSettings = */ settings,
+      /* project = */ project,
+      /* importResultCallback = */ { },
+      /* isPreviewMode = */ false,
+      /* progressExecutionMode = */ ProgressExecutionMode.IN_BACKGROUND_ASYNC,
+    )
+  }
+
+  override suspend fun unlinkProject(project: Project, externalProjectPath: String) {
+    val projectData = ExternalSystemApiUtil.findProjectNode(project, systemId, externalProjectPath)?.data ?: return
+    withContext(Dispatchers.EDT) {
+      DetachExternalProjectAction.detachProject(project, projectData.owner, projectData, null)
+    }
+  }
+}

packages/plugin-idea/src/main/kotlin/dev/elide/intellij/project/ElideProjectOpenProvider.kt

@@ -40,9 +40,6 @@ 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
  * IDE. Generally, the model can be built without calling the Elide CLI; however, in cases where the lockfile is out of
  * date, or dependencies are not installed, a command invocation will take place in a background task.
- *
- * The resolver is part of the auto-import feature, providing the actual import logic for the [ElideProjectAware]
- * tracker.
  */
 class ElideProjectResolver : ExternalSystemProjectResolver<ElideExecutionSettings> {
   private fun ExternalSystemTaskNotificationListener.onStep(taskId: ExternalSystemTaskId, text: String) {

packages/plugin-idea/src/main/kotlin/dev/elide/intellij/project/ElideProjectResolver.kt

@@ -0,0 +1,70 @@
+/*
+ * 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.project
+
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.externalSystem.autolink.ExternalSystemProjectLinkListener
+import com.intellij.openapi.externalSystem.autolink.ExternalSystemUnlinkedProjectAware
+import com.intellij.openapi.externalSystem.model.ProjectSystemId
+import com.intellij.openapi.externalSystem.settings.ExternalSystemSettingsListener
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFile
+import dev.elide.intellij.Constants
+import dev.elide.intellij.settings.ElideProjectSettings
+import dev.elide.intellij.settings.ElideSettings
+import java.util.concurrent.ConcurrentSkipListSet
+
+/**
+ * Tracking service used to link Elide projects when they are opened by the IDE. This class enables the auto-import
+ * and project sync features automatically, by configuring which files should be tracked by Intellij.
+ */
+@Suppress("UnstableApiUsage") class ElideUnlinkedProjectAware : ExternalSystemUnlinkedProjectAware {
+  private val linkedProjects = ConcurrentSkipListSet<String>()
+  override val systemId: ProjectSystemId = Constants.SYSTEM_ID
+
+  override fun isBuildFile(project: Project, buildFile: VirtualFile): Boolean {
+    return buildFile.name == Constants.MANIFEST_NAME
+  }
+
+  override fun isLinkedProject(project: Project, externalProjectPath: String): Boolean {
+    val settings = project.getService(ElideSettings::class.java)
+    return settings.getLinkedProjectSettings(externalProjectPath) != null
+  }
+
+  override fun subscribe(project: Project, listener: ExternalSystemProjectLinkListener, parentDisposable: Disposable) {
+    project.getService(ElideSettings::class.java).subscribe(
+      object : ExternalSystemSettingsListener<ElideProjectSettings?> {
+        override fun onProjectsLinked(settings: Collection<ElideProjectSettings?>) {
+          settings.forEach { if (it != null) listener.onProjectLinked(it.externalProjectPath) }
+        }
+
+        override fun onProjectsUnlinked(linkedProjectPaths: Set<String?>) {
+          linkedProjectPaths.forEach { if (it != null) listener.onProjectUnlinked(it) }
+        }
+      },
+      parentDisposable,
+    )
+  }
+
+  override suspend fun linkAndLoadProjectAsync(project: Project, externalProjectPath: String) {
+    linkedProjects.add(externalProjectPath)
+    ElideOpenProjectProvider().linkToExistingProjectAsync(externalProjectPath, project)
+
+  }
+
+  override suspend fun unlinkProject(project: Project, externalProjectPath: String) {
+    ElideOpenProjectProvider().unlinkProject(project, externalProjectPath)
+    linkedProjects.remove(externalProjectPath)
+  }
+}

packages/plugin-idea/src/main/kotlin/dev/elide/intellij/project/ElideUnlinkedProjectAware.kt

@@ -13,28 +13,73 @@
 
 package dev.elide.intellij.project.model
 
-import com.intellij.openapi.externalSystem.model.project.LibraryData
-import com.intellij.openapi.externalSystem.model.project.LibraryPathType
+import com.intellij.openapi.externalSystem.model.DataNode
+import com.intellij.openapi.externalSystem.model.ProjectKeys
+import com.intellij.openapi.externalSystem.model.project.*
 import dev.elide.intellij.Constants
 import java.nio.file.Path
 import kotlin.io.path.nameWithoutExtension
 import kotlin.io.path.pathString
 import elide.tooling.ClasspathSpec
 import elide.tooling.JvmMultiPathEntryType
+import elide.tooling.jvm.JvmLibraries
 import elide.tooling.jvm.resolver.MavenLockfileResolver
 import elide.tooling.lockfile.ElideLockfile
 import elide.tooling.project.ElideConfiguredProject
 import elide.tooling.project.SourceSet
+import elide.tooling.project.SourceSetLanguage
 import elide.tooling.project.SourceSetType
 
 /**
- * Provides library data from the resolved classpath stored in the project's lockfile, using a [MavenLockfileResolver].
+ * Adds library dependencies to a project and its modules, using the resolved dependency data from the Elide lockfile.
+ * Where applicable, built-in dependencies shipped with the runtime are also added.
  */
-class MavenLibraryContributor : LibraryDependencyContributor {
-  override suspend fun collectDependencies(
-    projectPath: Path,
+class ElideDependenciesContributor : ElideProjectModelContributor {
+  override suspend fun enhanceModule(
+    moduleNode: DataNode<ModuleData>,
     elideProject: ElideConfiguredProject,
-    sourceSet: SourceSet
+    elideSourceSet: SourceSet,
+    projectPath: Path
+  ) {
+    // add dependencies
+    val libraries = collectMavenDependencies(elideProject, elideSourceSet, projectPath) +
+            collectBuiltinDependencies(elideProject, elideSourceSet)
+
+    libraries.forEach {
+      moduleNode.createChild(
+        ProjectKeys.LIBRARY_DEPENDENCY,
+        LibraryDependencyData(moduleNode.data, it, LibraryLevel.MODULE),
+      )
+    }
+  }
+
+  /** Provides library data for dependencies that are bundled with Elide for JVM projects. */
+  private fun collectBuiltinDependencies(
+    elideProject: ElideConfiguredProject,
+    sourceSet: SourceSet,
+  ): Sequence<LibraryData> {
+    if (sourceSet.languages?.contains(SourceSetLanguage.Kotlin) != true) return emptySequence()
+
+    return JvmLibraries.builtinClasspath(
+      path = elideProject.resourcesPath,
+      tests = sourceSet.type == SourceSetType.Tests,
+      kotlin = true,
+    ).asSequence().map {
+      val library = LibraryData(Constants.SYSTEM_ID, it.path.pathString, false)
+      library.addPath(LibraryPathType.BINARY, it.path.pathString)
+
+      library
+    }
+  }
+
+  /**
+   * Provides library data from the resolved classpath stored in the project's lockfile, using a
+   * [MavenLockfileResolver].
+   */
+  private suspend fun collectMavenDependencies(
+    elideProject: ElideConfiguredProject,
+    sourceSet: SourceSet,
+    projectPath: Path
   ): Sequence<LibraryData> {
     val mavenLockfile = elideProject.activeLockfile
       ?.lockfile
@@ -58,8 +103,8 @@ class MavenLibraryContributor : LibraryDependencyContributor {
         val basePath = it.path.parent.resolve(it.path.nameWithoutExtension)
 
         library.addPath(LibraryPathType.BINARY, it.path.pathString)
-        library.addPath(LibraryPathType.SOURCE, "${basePath.pathString}$SUFFIX_SOURCES")
-        library.addPath(LibraryPathType.DOC, "${basePath.pathString}$SUFFIX_JAVADOC")
+        library.addPath(LibraryPathType.SOURCE, "${basePath.pathString}${SUFFIX_SOURCES}")
+        library.addPath(LibraryPathType.DOC, "${basePath.pathString}${SUFFIX_JAVADOC}")
 
         library
       }.orEmpty()