feat(shire): merge local agent language shire into AutoDev #379

Author: phodal

build.gradle.kts

@@ -783,6 +783,11 @@ project(":exts:devins-lang") {
             testFramework(TestFrameworkType.Plugin.Java)
         }
 
+        implementation("com.jayway.jsonpath:json-path:2.9.0")
+        implementation("org.reflections:reflections:0.10.2") {
+            exclude(group = "org.slf4j", module = "slf4j-api")
+        }
+
         implementation(project(":core"))
         implementation(project(":exts:ext-git"))
     }

core/src/legacy/embedding/InMemoryEmbeddingSearchIndex.kt

@@ -21,7 +21,7 @@ import kotlin.sequences.map
 import kotlin.to
 
 /**
- * Concurrent [com.phodal.shirecore.search.indices.EmbeddingSearchIndex] that stores all embeddings in the memory and allows
+ * Concurrent [cc.unitmesh.devti.language.search.indices.EmbeddingSearchIndex] that stores all embeddings in the memory and allows
  * simultaneous read operations from multiple consumers.
  * Can be persisted to disk.
  */

core/src/main/kotlin/cc/unitmesh/devti/custom/compile/VariableTemplateCompiler.kt

@@ -15,6 +15,8 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiNameIdentifierOwner
 import cc.unitmesh.devti.intentions.action.getElementToAction
+import com.intellij.openapi.application.ReadAction
+import com.intellij.psi.PsiManager
 import kotlinx.coroutines.runBlocking
 import org.apache.velocity.VelocityContext
 import org.apache.velocity.app.Velocity
@@ -41,6 +43,12 @@ class VariableTemplateCompiler(
         velocityContext.put(key, value)
     }
 
+    fun putAll(map: Map<String, Any>) {
+        map.forEach { (key, value) ->
+            velocityContext.put(key, value)
+        }
+    }
+
     fun compile(template: String): String {
         velocityContext.put(CustomVariable.FILE_NAME.variable, file.name)
         velocityContext.put(CustomVariable.FILE_PATH.variable, file.virtualFile?.path ?: "")
@@ -119,5 +127,24 @@ class VariableTemplateCompiler(
                 selectedText = selectedText,
             )
         }
+
+        fun defaultEditor(myProject: Project): Editor? {
+            return FileEditorManager.getInstance(myProject).selectedTextEditor
+        }
+
+        fun defaultElement(myProject: Project, currentEditor: Editor?): PsiElement? =
+            ReadAction.compute<PsiElement?, Throwable> {
+                currentEditor?.caretModel?.currentCaret?.offset?.let {
+                    val psiFile = currentEditor.let { editor ->
+                        val psiFile = editor.virtualFile?.let { file ->
+                            PsiManager.getInstance(myProject).findFile(file)
+                        }
+
+                        psiFile
+                    } ?: return@let null
+
+                    psiFile.findElementAt(it) ?: return@let psiFile
+                }
+            }
     }
 }

core/src/main/kotlin/cc/unitmesh/devti/custom/team/InteractionType.kt

@@ -1,11 +1,34 @@
 package cc.unitmesh.devti.custom.team
 
-enum class InteractionType {
-    ChatPanel,
-    AppendCursor,
-    AppendCursorStream,
-    OutputFile,
-    ReplaceSelection,
-    ReplaceCurrentFile,
+enum class InteractionType(val description: String) {
+    AppendCursor("Append content at the current cursor position"),
+    AppendCursorStream("Append content at the current cursor position, stream output"),
+    OutputFile("Output to a new file"),
+    ReplaceSelection("Replace the currently selected content"),
+    ReplaceCurrentFile("Replace the content of the current file"),
+    InsertBeforeSelection("Insert content before the currently selected content"),
+    RunPanel("Show Result in Run panel which is the bottom of the IDE"),
+    ChatPanel("Show Result in Chat panel which is the right of the IDE"),
+    OnPaste("Copy the content to the clipboard"),
+    RightPanel("Show Result in Right panel which is the right of the IDE"),
+    StreamDiff("Use streaming diff to show the result")
     ;
+
+    companion object {
+        fun from(interaction: String): InteractionType {
+            return when (interaction.lowercase()) {
+                AppendCursor.name.lowercase() -> InteractionType.AppendCursor
+                AppendCursorStream.name.lowercase() -> InteractionType.AppendCursorStream
+                OutputFile.name.lowercase() -> InteractionType.OutputFile
+                ReplaceSelection.name.lowercase() -> InteractionType.ReplaceSelection
+                ReplaceCurrentFile.name.lowercase() -> InteractionType.ReplaceCurrentFile
+                InsertBeforeSelection.name.lowercase() -> InsertBeforeSelection
+                RunPanel.name.lowercase() -> InteractionType.RunPanel
+                OnPaste.name.lowercase() -> OnPaste
+                RightPanel.name.lowercase() -> RightPanel
+                StreamDiff.name.lowercase() -> StreamDiff
+                else -> RunPanel
+            }
+        }
+    }
 }

core/src/main/kotlin/cc/unitmesh/devti/custom/team/TeamPromptExecTask.kt

@@ -1,12 +1,17 @@
 package cc.unitmesh.devti.custom.team
 
 import cc.unitmesh.cf.core.llms.LlmMsg
+import cc.unitmesh.cf.core.llms.LlmProvider
 import cc.unitmesh.devti.AutoDevBundle
 import cc.unitmesh.devti.custom.tasks.FileGenerateTask
 import cc.unitmesh.devti.gui.chat.message.ChatActionType
 import cc.unitmesh.devti.gui.sendToChatWindow
 import cc.unitmesh.devti.intentions.action.task.BaseCompletionTask
 import cc.unitmesh.devti.intentions.action.task.CodeCompletionRequest
+import cc.unitmesh.devti.llms.LlmFactory
+import cc.unitmesh.devti.util.AutoDevCoroutineScope
+import com.intellij.execution.ui.ConsoleViewContentType
+import com.intellij.openapi.application.invokeLater
 import com.intellij.openapi.application.runReadAction
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.progress.ProgressIndicator
@@ -16,6 +21,9 @@ import com.intellij.openapi.progress.impl.BackgroundableProcessIndicator
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiElement
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.cancellable
+import kotlinx.coroutines.launch
 
 /**
  * The `TeamPromptExecTask` class is a background task that executes a team prompt action in the context of a project.
@@ -98,6 +106,12 @@ class TeamPromptExecTask(
                 ProgressManager.getInstance()
                     .runProcessWithProgressAsynchronously(task, BackgroundableProcessIndicator(task))
             }
+
+            InteractionType.InsertBeforeSelection -> TODO()
+            InteractionType.RunPanel -> TODO()
+            InteractionType.OnPaste -> TODO()
+            InteractionType.RightPanel -> TODO()
+            InteractionType.StreamDiff -> TODO()
         }
     }
 }

core/src/main/kotlin/cc/unitmesh/devti/provider/toolchain/ToolchainFunctionProvider.kt

@@ -26,5 +26,11 @@ interface ToolchainFunctionProvider {
                 it.javaClass.simpleName == providerName
             }
         }
+
+        suspend fun provide(project: Project, funcName: String): ToolchainFunctionProvider? {
+            return EP_NAME.extensionList.firstOrNull {
+                it.isApplicable(project, funcName)
+            }
+        }
     }
 }

core/src/main/kotlin/cc/unitmesh/devti/util/AutoDevCoroutineScope.kt

@@ -8,7 +8,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.util.concurrency.AppExecutorUtil
 import kotlinx.coroutines.*
 
-private val workerThread = AppExecutorUtil.getAppExecutorService().asCoroutineDispatcher()
+public val workerThread = AppExecutorUtil.getAppExecutorService().asCoroutineDispatcher()
 
 @Service(Service.Level.APP)
 class AutoDevAppScope: Disposable {

core/src/main/resources/messages/AutoDevBundle_en.properties

@@ -266,3 +266,4 @@ mcp.preview.editor.loading.response=Loading response...
 mcp.editor.preview.title=Preview
 mcp.editor.preview.tooltip=Preview panel
 mcp.editor.refresh.title=Refresh
+shire.toolchain.function.not.found=Toolchain Not Found

core/src/main/resources/messages/AutoDevBundle_zh.properties

@@ -256,3 +256,4 @@ mcp.preview.editor.loading.response=加载响应中...
 mcp.editor.preview.title=预览
 mcp.editor.preview.tooltip=预览面板
 mcp.editor.refresh.title=刷新
+shire.toolchain.function.not.found=Toolchain Not Found

exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/actions/DevInsRunFileAction.kt

@@ -1,20 +1,29 @@
 package cc.unitmesh.devti.language.actions
 
+import cc.unitmesh.devti.startup.DynamicDevInActionConfig
+import cc.unitmesh.devti.language.middleware.post.PostProcessorContext
 import cc.unitmesh.devti.language.psi.DevInFile
 import cc.unitmesh.devti.language.run.DevInsConfiguration
 import cc.unitmesh.devti.language.run.DevInsConfigurationType
 import cc.unitmesh.devti.language.run.DevInsRunConfigurationProducer
+import cc.unitmesh.devti.language.status.DevInsRunListener
 import com.intellij.execution.ExecutionManager
 import com.intellij.execution.RunManager
 import com.intellij.execution.actions.ConfigurationContext
 import com.intellij.execution.actions.RunConfigurationProducer
 import com.intellij.execution.executors.DefaultRunExecutor
+import com.intellij.execution.process.ProcessEvent
 import com.intellij.execution.runners.ExecutionEnvironmentBuilder
 import com.intellij.openapi.actionSystem.ActionUpdateThread
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.project.DumbAwareAction
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Disposer
 import org.jetbrains.annotations.NonNls
+import java.util.concurrent.CompletableFuture
 
 class DevInsRunFileAction : DumbAwareAction() {
     override fun getActionUpdateThread(): ActionUpdateThread = ActionUpdateThread.BGT
@@ -50,6 +59,83 @@ class DevInsRunFileAction : DumbAwareAction() {
 
     companion object {
         val ID: @NonNls String = "runDevInsFileAction"
+
+        fun suspendExecuteFile(
+            project: Project,
+            file: DevInFile,
+            variableNames: Array<String> = arrayOf(),
+            variableTable: MutableMap<String, Any?> = mutableMapOf(),
+        ): String? {
+            val variables: MutableMap<String, String> = mutableMapOf()
+            for (i in variableNames.indices) {
+                val varName = variableNames[i]
+                val varValue = variableTable[varName].toString()
+                variables[varName] = varValue
+            }
+
+            val config = DynamicDevInActionConfig.from(file)
+
+            val settings = try {
+                RunManager.getInstance(project)
+                    .createConfiguration(config.name, DevInsConfigurationType::class.java)
+            } catch (e: Exception) {
+                logger<DevInsRunFileAction>().error("Failed to create configuration", e)
+                return null
+            }
+
+            val runConfiguration = settings.configuration as DevInsConfiguration
+            runConfiguration.setScriptPath(config.devinFile.virtualFile.path)
+            if (variables.isNotEmpty()) {
+                runConfiguration.setVariables(variables)
+                PostProcessorContext.updateRunConfigVariables(variables)
+            }
+
+            val executorInstance = DefaultRunExecutor.getRunExecutorInstance()
+            val executionEnvironment = ExecutionEnvironmentBuilder
+                .createOrNull(executorInstance, runConfiguration)
+                ?.build()
+
+            if (executionEnvironment == null) {
+                logger<DevInsRunFileAction>().error("Failed to create execution environment")
+                return null
+            }
+
+            val future = CompletableFuture<String>()
+
+            val hintDisposable = Disposer.newDisposable()
+            val connection = ApplicationManager.getApplication().messageBus.connect(hintDisposable)
+            connection.subscribe(DevInsRunListener.TOPIC, object : DevInsRunListener {
+//                override fun runFinish(
+//                    allOutput: String,
+//                    llmOutput: String,
+//                    event: ProcessEvent,
+//                    scriptPath: String,
+//                    consoleView: DevInConsoleView?,
+//                ) {
+//                    future.complete(llmOutput)
+//                    connection.disconnect()
+//                    Disposer.dispose(hintDisposable)
+//                }
+                override fun runFinish(
+                    string: String,
+                    event: ProcessEvent,
+                    scriptPath: String
+                ) {
+
+                }
+            })
+
+            ExecutionManager.getInstance(project).restartRunProfile(
+                project,
+                executorInstance,
+                executionEnvironment.executionTarget,
+                settings,
+                null
+            )
+
+            return future.get()
+        }
+
     }
 
 }

exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/ast/ExpressionBuiltInMethod.kt

@@ -0,0 +1,37 @@
+package cc.unitmesh.devti.language.ast
+
+/**
+ * This enum class `ExpressionBuiltInMethod` provides a set of built-in methods for string manipulation in Kotlin.
+ * Each enum constant represents a specific built-in method, and holds information about the method's name, description,
+ * the string to be inserted after the method call, and the position to move the caret to after insertion.
+ *
+ */
+enum class ExpressionBuiltInMethod(
+    val methodName: String,
+    val description: String,
+    val postInsertString: String = "()",
+    val moveCaret: Int = 2,
+) {
+    LENGTH("length", "The length of the string"),
+    TRIM("trim", "The trimmed string"),
+    CONTAINS("contains", "Check if the string contains a substring", "(\"\")", 2),
+    STARTS_WITH("startsWith", "Check if the string starts with a substring", "(\"\")", 2),
+    ENDS_WITH("endsWith", "Check if the string ends with a substring", "(\"\")", 2),
+    LOWERCASE("lowercase", "The lowercase version of the string"),
+    UPPERCASE("uppercase", "The uppercase version of the string"),
+    IS_EMPTY("isEmpty", "Check if the string is empty"),
+    IS_NOT_EMPTY("isNotEmpty", "Check if the string is not empty"),
+    FIRST("first", "The first character of the string"),
+    LAST("last", "The last character of the string"),
+    MATCHES("matches", "Check if the string matches a regex pattern", "(\"//\")", 3);
+
+    companion object {
+        fun fromString(methodName: String): ExpressionBuiltInMethod? {
+            return values().find { it.methodName == methodName }
+        }
+
+        fun completionProvider(): Array<ExpressionBuiltInMethod> {
+            return values()
+        }
+    }
+}

exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/ast/ForeignFunction.kt

@@ -0,0 +1,28 @@
+package cc.unitmesh.devti.language.ast
+
+data class ForeignFunction(
+    val funcName: String,
+    val funcPath: String,
+    val accessFuncName: String,
+    val inputTypes: List<String>,
+    val returnVars: Map<String, Any>,
+) {
+    companion object {
+        fun from(map: Map<String, FrontMatterType>): List<ForeignFunction> {
+            return map
+                .filter { (_, value) ->
+                    value is FrontMatterType.EXPRESSION && value.value is ForeignFunctionStmt
+                }
+                .map { (key, value) ->
+                    val stmt = value.value as ForeignFunctionStmt
+                    ForeignFunction(
+                        key,
+                        stmt.funcPath,
+                        stmt.accessFuncName,
+                        stmt.inputTypes,
+                        stmt.returnVars
+                    )
+                }
+        }
+    }
+}