feat(idea): project and plugin settings

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

Author: darvld

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

@@ -44,6 +44,15 @@ object Constants {
   /** Name and extension of the Elide lockfile. */
   const val LOCKFILE_NAME = "elide.lock.bin"
 
+  /** Default installation directory for Elide under the user home path. */
+  const val ELIDE_HOME = "elide"
+
+  /** Resources path relative to the root of the Elide distribution. */
+  const val ELIDE_RESOURCES_DIR = "resources"
+
+  /** Relative path to the CLI binary in an Elide distribution. */
+  const val ELIDE_BINARY = "elide"
+
   /** Descriptor for a file chooser to be used when selecting an Elide project. */
   @JvmStatic fun projectFileChooser(): FileChooserDescriptor {
     return FileChooserDescriptor(
@@ -56,6 +65,18 @@ object Constants {
     ).withFileFilter { it.name == MANIFEST_NAME }
   }
 
+  /** Descriptor for a file chooser to be used when selecting an Elide distribution. */
+  @JvmStatic fun sdkFileChooser(): FileChooserDescriptor {
+    return FileChooserDescriptor(
+      /* chooseFiles = */ false,
+      /* chooseFolders = */ true,
+      /* chooseJars = */ false,
+      /* chooseJarsAsFiles = */ false,
+      /* chooseJarContents = */ false,
+      /* chooseMultiple = */ false,
+    )
+  }
+
   data object Icons {
     @JvmStatic private val LOG = Logger.getInstance(Icons::class.java)
 

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

@@ -16,16 +16,19 @@ package dev.elide.intellij
 import com.intellij.execution.configurations.SimpleJavaParameters
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.externalSystem.ExternalSystemAutoImportAware
+import com.intellij.openapi.externalSystem.ExternalSystemConfigurableAware
 import com.intellij.openapi.externalSystem.ExternalSystemManager
 import com.intellij.openapi.externalSystem.model.ProjectSystemId
 import com.intellij.openapi.externalSystem.service.project.ExternalSystemProjectResolver
 import com.intellij.openapi.externalSystem.service.project.autoimport.CachingExternalSystemAutoImportAware
 import com.intellij.openapi.externalSystem.task.ExternalSystemTaskManager
 import com.intellij.openapi.fileChooser.FileChooserDescriptor
+import com.intellij.openapi.options.Configurable
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Pair
 import com.intellij.util.Function
 import dev.elide.intellij.project.ElideProjectResolver
+import dev.elide.intellij.service.ElideDistributionResolver
 import dev.elide.intellij.settings.*
 import dev.elide.intellij.tasks.ElideTaskManager
 import java.io.File
@@ -47,7 +50,7 @@ import java.io.File
  * actions, etc. Some additional parts, such as the [dev.elide.intellij.startup.ElideStartupActivity], are used
  * to complement those features and improve the experience (e.g. by scanning for a project on startup).
  */
-class ElideManager : ExternalSystemAutoImportAware, ExternalSystemManager<
+class ElideManager : ExternalSystemAutoImportAware, ExternalSystemConfigurableAware, ExternalSystemManager<
         ElideProjectSettings,
         ElideSettingsListener,
         ElideSettings,
@@ -60,7 +63,7 @@ class ElideManager : ExternalSystemAutoImportAware, ExternalSystemManager<
   override fun getSystemId(): ProjectSystemId = Constants.SYSTEM_ID
 
   override fun getSettingsProvider(): Function<Project, ElideSettings> = Function { project ->
-    project.getService(ElideSettings::class.java)
+    ElideSettings.getSettings(project)
   }
 
   override fun getLocalSettingsProvider(): Function<Project, ElideLocalSettings> = Function { project ->
@@ -71,9 +74,14 @@ class ElideManager : ExternalSystemAutoImportAware, ExternalSystemManager<
     val project = it.first
     val path = it.second
 
+    val settings = ElideSettings.getSettings(project)
+
     LOG.debug("Preparing execution settings for project at '$path': $project")
-    val settings = ElideExecutionSettings()
-    settings
+    ElideExecutionSettings(
+      elideHome = ElideDistributionResolver.getElideHome(project, path),
+      downloadSources = settings.downloadSources,
+      downloadDocs = settings.downloadDocs,
+    )
   }
 
   override fun getProjectResolverClass(): Class<out ExternalSystemProjectResolver<ElideExecutionSettings>> {
@@ -101,6 +109,10 @@ class ElideManager : ExternalSystemAutoImportAware, ExternalSystemManager<
     return autoImportDelegate.getAffectedExternalProjectFiles(projectPath, project)
   }
 
+  override fun getConfigurable(project: Project): Configurable {
+    return ElideConfigurable(project)
+  }
+
   private companion object {
     @JvmStatic private val LOG = Logger.getInstance(ElideManager::class.java)
   }

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

@@ -25,6 +25,7 @@ import com.intellij.openapi.progress.runBlockingCancellable
 import dev.elide.intellij.Constants
 import dev.elide.intellij.manifests.ElideManifestService
 import dev.elide.intellij.project.model.ElideProjectModel
+import dev.elide.intellij.service.ElideDistributionResolver
 import dev.elide.intellij.settings.ElideExecutionSettings
 import org.jetbrains.annotations.PropertyKey
 import java.nio.file.Path
@@ -107,13 +108,17 @@ class ElideProjectResolver : ExternalSystemProjectResolver<ElideExecutionSetting
    * 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 {
+  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")
+      override val resourcesPath: Path by lazy {
+        val elideHome = settings?.elideHome ?: ElideDistributionResolver.defaultDistributionPath()
+        ElideDistributionResolver.resourcesPath(elideHome)
+      }
     }
   }
 

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

@@ -23,27 +23,25 @@ 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)
+    val settings = ElideSettings.getSettings(project)
     return settings.getLinkedProjectSettings(externalProjectPath) != null
   }
 
   override fun subscribe(project: Project, listener: ExternalSystemProjectLinkListener, parentDisposable: Disposable) {
-    project.getService(ElideSettings::class.java).subscribe(
+    ElideSettings.getSettings(project).subscribe(
       object : ExternalSystemSettingsListener<ElideProjectSettings?> {
         override fun onProjectsLinked(settings: Collection<ElideProjectSettings?>) {
           settings.forEach { if (it != null) listener.onProjectLinked(it.externalProjectPath) }
@@ -58,13 +56,11 @@ import java.util.concurrent.ConcurrentSkipListSet
   }
 
   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/service/ElideCliService.kt

@@ -0,0 +1,116 @@
+/*
+ * 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.service
+
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.io.toCanonicalPath
+import com.intellij.util.io.awaitExit
+import dev.elide.intellij.Constants
+import java.io.File
+import java.nio.file.Path
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+
+/**
+ * Project-level service responsible for interfacing with the Elide CLI binary. Methods in this class expose relevant
+ * CLI commands using coroutines and provide a wrapper for the result with [ElideProcess].
+ */
+@Service(Service.Level.PROJECT)
+class ElideCliService(private val project: Project, private val serviceScope: CoroutineScope) {
+  /**
+   * Encapsulates a call to the Elide CLI running as a subprocess launched by [ProcessBuilder]. Awaiting this value
+   * will return the exit code of the process once it finishes.
+   *
+   * Use [readStdOut] and [readStdErr] to consume the entirety of the process's output and error streams, or manually
+   * collect the [stdOut] and [stdErr] flows for better control.
+   */
+  class ElideProcess private constructor(
+    private val process: Process,
+    processScope: CoroutineScope,
+    exitCode: Deferred<Int>
+  ) : Deferred<Int> by exitCode {
+    /**
+     * Shared flow connected to the process's standard output stream; a buffered reader is used to emit each line from
+     * a background thread while subscribers are active.
+     */
+    val stdOut: Flow<String> = flow {
+      process.inputStream.bufferedReader().useLines { lines ->
+        lines.forEach { emit(it) }
+      }
+    }.flowOn(Dispatchers.IO).shareIn(processScope, SharingStarted.WhileSubscribed())
+
+    /**
+     * Shared flow connected to the process's standard error stream; a buffered reader is used to emit each line from
+     * a background thread while subscribers are active.
+     */
+    val stdErr: Flow<String> = flow {
+      process.errorStream.bufferedReader().useLines { lines ->
+        lines.forEach { emit(it) }
+      }
+    }.flowOn(Dispatchers.IO).shareIn(processScope, SharingStarted.WhileSubscribed())
+
+    /** Read the process's standard output stream in its entirety, suspending until it is closed. */
+    suspend fun readStdOut() = withContext(Dispatchers.IO) {
+      process.inputStream.bufferedReader().readText()
+    }
+
+    /** Read the process's standard error stream in its entirety, suspending until it is closed. */
+    suspend fun readStdErr() = withContext(Dispatchers.IO) {
+      process.errorStream.bufferedReader().readText()
+    }
+
+    companion object {
+      /**
+       * Launch the Elide CLI binary using [ProcessBuilder] and wrap it as an [ElideProcess]. This function is meant
+       * to be used by the [ElideCliService], which automatically handles path resolution and provides an execution
+       * context.
+       */
+      fun launch(
+        elideBinary: Path,
+        projectPath: String,
+        scope: CoroutineScope,
+        buildCommand: MutableList<String>.() -> Unit
+      ): ElideProcess {
+        val command = buildList {
+          add(elideBinary.toCanonicalPath())
+          buildCommand()
+        }
+
+        val process = ProcessBuilder(command)
+          .directory(File(projectPath))
+          .start()
+
+        return ElideProcess(process, scope, scope.async { process.awaitExit() })
+      }
+    }
+  }
+
+  /**
+   * Launch the Elide CLI binary as a subprocess and wrap it in [ElideProcess] for easy handling. The settings of the
+   * linked project at [projectPath] are used to select an Elide distribution to be invoked.
+   */
+  private fun launchElide(projectPath: String, buildCommand: MutableList<String>.() -> Unit): ElideProcess {
+    val elideHome = ElideDistributionResolver.getElideHome(project, projectPath)
+    val elideBin = elideHome.resolve(Constants.ELIDE_BINARY)
+
+    return ElideProcess.launch(elideBin, projectPath, serviceScope, buildCommand)
+  }
+
+  /** Invoke the Elide CLI with the `--version` option in a background context and return its output. */
+  fun version(projectPath: String): Deferred<String> = serviceScope.async {
+    val elide = launchElide(projectPath, buildCommand = { add("--version") })
+    elide.readStdOut()
+  }
+}

packages/plugin-idea/src/main/kotlin/dev/elide/intellij/service/ElideDistributionResolver.kt

@@ -0,0 +1,99 @@
+/*
+ * 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.service
+
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.project.Project
+import dev.elide.intellij.Constants
+import dev.elide.intellij.service.ElideDistributionResolver.Companion.defaultDistributionPath
+import dev.elide.intellij.service.ElideDistributionResolver.Companion.getElideHome
+import dev.elide.intellij.service.ElideDistributionResolver.Companion.resourcesPath
+import dev.elide.intellij.service.ElideDistributionResolver.Companion.validateDistributionPath
+import dev.elide.intellij.settings.ElideDistributionSetting
+import dev.elide.intellij.settings.ElideSettings
+import java.nio.file.Path
+import kotlin.io.path.Path
+import kotlin.io.path.isDirectory
+import kotlin.io.path.isRegularFile
+
+/**
+ * Service used to resolve an Elide distribution for a project; use the static [getElideHome] function to obtain a
+ * distribution path that respects project configuration, with a fallback to [defaultDistributionPath].
+ *
+ * For simple validation cases, [validateDistributionPath] can be used to verify that a minimal distribution structure
+ * is present in the selected Elide home directory.
+ */
+@Service(Service.Level.PROJECT)
+class ElideDistributionResolver(private val project: Project) {
+  /**
+   * Resolve the path to the preferred Elide distribution for the linked project at [externalProjectPath]. If no linked
+   * settings are found, [defaultDistributionPath] is returned instead.
+   *
+   * The returned path is *not* validated by [validateDistributionPath] or in any other way; it is the responsibility
+   * of the caller to properly check that the path correspond to a valid Elide distribution before using it as such.
+   */
+  fun resolveDistributionPath(externalProjectPath: String): Path {
+    val settings = ElideSettings.getSettings(project)
+      .getLinkedProjectSettings(externalProjectPath)
+      ?: return defaultDistributionPath()
+
+    return when (settings.elideDistributionType) {
+      ElideDistributionSetting.Custom -> Path(settings.elideDistributionPath).normalize()
+      ElideDistributionSetting.AutoDetect -> defaultDistributionPath()
+    }
+  }
+
+  companion object {
+    /**
+     * Returns the path to the preferred Elide distribution for a linked external project, or the
+     * [defaultDistributionPath] if no project settings are found.
+     *
+     * The returned path is *not* validated by [validateDistributionPath] or in any other way; it is the responsibility
+     * of the caller to properly check that the path correspond to a valid Elide distribution before using it as such.
+     */
+    @JvmStatic fun getElideHome(project: Project, externalProjectPath: String): Path {
+      return project.getService(ElideDistributionResolver::class.java).resolveDistributionPath(externalProjectPath)
+    }
+
+    /**
+     * Returns the default path to the Elide installation in the user's home directory. Note that the path is not
+     * guaranteed to contain a valid distribution or even exist.
+     */
+    @JvmStatic fun defaultDistributionPath(): Path {
+      return Path(System.getProperty("user.home")).resolve(Constants.ELIDE_HOME)
+    }
+
+    /**
+     * Shorthand for resolving the [resourcesPath] in the [preferred Elide distribution][getElideHome] for a linked
+     * external project.
+     */
+    @JvmStatic fun resourcesPath(project: Project, externalProjectPath: String): Path {
+      val elideHome = getElideHome(project, externalProjectPath)
+      return elideHome.resolve(Constants.ELIDE_RESOURCES_DIR)
+    }
+
+    /** Returns the path to the resources directory inside the given Elide distribution. */
+    @JvmStatic fun resourcesPath(elideHome: Path): Path {
+      return elideHome.resolve(Constants.ELIDE_RESOURCES_DIR)
+    }
+
+    /** Lightly validates an Elide distribution [path], verifying some basic directories and files are presents. */
+    @JvmStatic fun validateDistributionPath(path: Path): Boolean {
+      if (!path.resolve(Constants.ELIDE_RESOURCES_DIR).isDirectory()) return false
+      if (!path.resolve(Constants.ELIDE_BINARY).isRegularFile()) return false
+
+      return true
+    }
+  }
+}