feat(idea): call elide install during project sync

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

Author: darvld

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

@@ -0,0 +1,83 @@
+package dev.elide.intellij.cli
+
+import com.intellij.openapi.project.Project
+import com.intellij.util.io.awaitExit
+import dev.elide.intellij.Constants
+import dev.elide.intellij.service.ElideDistributionResolver
+import java.nio.file.Path
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
+
+/**
+ * Bridge service used to invoke the Elide CLI on a configured distribution. Use [ElideCommandLine.at] to manually set
+ * the path to the distribution or [ElideCommandLine.resolve] to automatically retrieve the path from the project
+ * settings.
+ */
+class ElideCommandLine private constructor(
+  private val elideHome: Path,
+  private val workDir: Path? = null,
+) {
+  /**
+   * Launch the Elide CLI binary as a subprocess and suspend until it finishes executing. The supplied [block] will
+   * be called after the process is launched, and can be used to interact with it in any way; note that it is not
+   * necessary to use [awaitExit] in [block], as it is already called before returning.
+   *
+   * Calling this method directly is discouraged in favor of command-specific extensions like [install], which provide
+   * type-safe handling of arguments.
+   */
+  suspend operator fun <R> invoke(
+    buildCommand: MutableList<String>.() -> Unit,
+    block: suspend CoroutineScope.(Process) -> R
+  ): R {
+    val elideBin = elideHome.resolve(Constants.ELIDE_BINARY)
+    val command = buildList {
+      add(elideBin.toString())
+      buildCommand()
+    }
+
+    val process = ProcessBuilder(command)
+      .also { if (workDir != null) it.directory(workDir.toFile()) }
+      .start()
+
+    return coroutineScope {
+      val result = async { block(process) }
+
+      process.awaitExit()
+      result.await()
+    }
+  }
+
+  companion object {
+    /** Returns an [ElideCommandLine] at the given [elideHome], optionally using [workDir] when invoking commands. */
+    @JvmStatic fun at(elideHome: Path, workDir: Path? = null): ElideCommandLine {
+      return ElideCommandLine(elideHome, workDir)
+    }
+
+    /** Returns an [ElideCommandLine] configured according to a linked external project's settings. */
+    @JvmStatic fun resolve(project: Project, externalProjectPath: String, workDir: Path? = null): ElideCommandLine {
+      return at(ElideDistributionResolver.getElideHome(project, externalProjectPath), workDir)
+    }
+  }
+}
+
+/**
+ * Calls `elide install`, optionally passing [`--with=sources`][withSources] and [`--with=docs`][withDocs], and returns
+ * the exit code. The [useProcess] block can be used to access the output streams for monitoring the operation.
+ */
+suspend fun ElideCommandLine.install(
+  withSources: Boolean = true,
+  withDocs: Boolean = true,
+  useProcess: suspend CoroutineScope.(Process) -> Unit = {},
+): Int {
+  return invoke(
+    buildCommand = {
+      add("install")
+      if (withSources) add("--with=sources")
+      if (withDocs) add("--with=docs")
+    },
+  ) {
+    useProcess(it)
+    it.awaitExit()
+  }
+}

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

@@ -21,14 +21,18 @@ 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 com.intellij.openapi.progress.coroutineToIndicator
 import com.intellij.openapi.progress.runBlockingCancellable
 import dev.elide.intellij.Constants
+import dev.elide.intellij.cli.ElideCommandLine
+import dev.elide.intellij.cli.install
 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
+import kotlinx.coroutines.launch
 import kotlin.io.path.Path
 import kotlin.io.path.notExists
 import elide.tooling.lockfile.LockfileLoader
@@ -65,6 +69,9 @@ class ElideProjectResolver : ExternalSystemProjectResolver<ElideExecutionSetting
     listener: ExternalSystemTaskNotificationListener
   ): DataNode<ProjectData>? {
     return runBlockingCancellable {
+      coroutineToIndicator {
+
+      }
       LOG.debug("Resolving project at '$projectPath'")
 
       val projectModel = runCatching {
@@ -82,14 +89,35 @@ class ElideProjectResolver : ExternalSystemProjectResolver<ElideExecutionSetting
         listener.onStep(id, progressMessage("resolve.steps.parse"))
         val manifest = ElideManifestService().parse(manifestPath)
 
-        // call the CLI in case the lockfile is outdated
-        listener.onStep(id, progressMessage("resolve.steps.refresh"))
-
         // configure the project
         listener.onStep(id, progressMessage("resolve.steps.configure"))
         val loader = buildProjectLoader(projectRoot, settings)
         val project = ElideProjectInfo(projectRoot, manifest, null).load(loader)
 
+        // call the CLI in case the lockfile is outdated
+        listener.onStep(id, progressMessage("resolve.steps.refresh"))
+        val elideHome = settings?.elideHome ?: ElideDistributionResolver.defaultDistributionPath()
+        val cli = ElideCommandLine.at(elideHome, projectRoot)
+
+        val exitCode = cli.install(
+          withSources = settings?.downloadSources ?: true,
+          withDocs = settings?.downloadDocs ?: true,
+        ) { process ->
+          // pass process output on to the IDE
+          launch {
+            process.inputStream.bufferedReader().forEachLine {
+              listener.onTaskOutput(id, "$it\n", true)
+            }
+          }
+          launch {
+            process.errorStream.bufferedReader().forEachLine {
+              listener.onTaskOutput(id, "$it\n", false)
+            }
+          }
+        }
+
+        if (exitCode != 0) error("Command 'elide install' failed with exit code $exitCode")
+
         // build the project model from the manifest and lockfile
         listener.onStep(id, progressMessage("resolve.steps.buildModel"))
         ElideProjectModel.buildProjectModel(projectRoot, project)