feat(devin-lang): add support for file path processing in DevInCompiler #101

This commit introduces a new feature to the DevInCompiler class, which allows for the processing of file paths specified in DevInFile commands. It includes the ability to extract a range from a file using a comment-based syntax, and to read the contents of a file from the project directory. Additionally, the compiler now handles various built-in commands more robustly, with logging for missing command properties and proper handling of each command type.

Author: phodal

exts/devin-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/DevInCompiler.kt

@@ -7,9 +7,14 @@ import cc.unitmesh.devti.language.psi.DevInUsed
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.project.guessProjectDir
+import com.intellij.openapi.util.NlsSafe
+import com.intellij.openapi.util.TextRange
+import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.util.elementType
+import kotlin.io.path.readText
 
-class DevInCompiler(val project: Project, val file: DevInFile, val editor: Editor) {
+class DevInCompiler(val myProject: Project, val file: DevInFile, val editor: Editor? = null) {
     private val logger = logger<DevInCompiler>()
     private val output: StringBuilder = StringBuilder()
 
@@ -38,27 +43,27 @@ class DevInCompiler(val project: Project, val file: DevInFile, val editor: Edito
 
     private fun processUsed(used: DevInUsed) {
         val firstChild = used.firstChild
-        val id = used.children.getOrNull(1)
+        val id = firstChild.nextSibling
 
         when (firstChild.elementType) {
             DevInTypes.COMMAND_START -> {
-                /**
-                 *
-                 */
-
                 val command = BuiltinCommand.fromString(id?.text ?: "")
                 if (command == null) {
                     output.append(used.text)
                     logger.warn("Unknown command: ${id?.text}")
                     return
                 }
 
-                when (command) {
-                    BuiltinCommand.FILE -> TODO()
-                    BuiltinCommand.REV -> TODO()
-                    BuiltinCommand.SYMBOL -> TODO()
-                    BuiltinCommand.WRITE -> TODO()
+
+                val propElement = id.nextSibling?.nextSibling
+                val isProp = (propElement.elementType == DevInTypes.COMMAND_PROP)
+                if (!isProp) {
+                    output.append(used.text)
+                    logger.warn("No command prop found: ${used.text}")
+                    return
                 }
+
+                processingCommand(command, propElement!!.text)
             }
 
             DevInTypes.AGENT_START -> {
@@ -79,4 +84,40 @@ class DevInCompiler(val project: Project, val file: DevInFile, val editor: Edito
             }
         }
     }
+
+    private fun processingCommand(command: BuiltinCommand, prop: @NlsSafe String) {
+        when (command) {
+            BuiltinCommand.FILE -> {
+                val range: TextRange? = if (prop.contains("#")) {
+                    val rangeStr = prop.substringAfter("#")
+                    val start = rangeStr.substringBefore("-").toInt()
+                    val end = rangeStr.substringAfter("-").toInt()
+                    TextRange(start, end)
+                } else {
+                    null
+                }
+
+                val filepath = prop.trim()
+                val projectPath = myProject.guessProjectDir()?.toNioPath()
+                val content = projectPath?.resolve(filepath)?.readText()
+                content?.let {
+                    output.append(content)
+                }
+
+            }
+
+            BuiltinCommand.REV -> {
+                logger.info("handling rev")
+                output.append(command.agentName)
+            }
+            BuiltinCommand.SYMBOL -> {
+                logger.info("handling symbol")
+                output.append(command.agentName)
+            }
+            BuiltinCommand.WRITE -> {
+                logger.info("handling write")
+                output.append(command.agentName)
+            }
+        }
+    }
 }

exts/devin-lang/src/main/kotlin/cc/unitmesh/devti/language/run/DevInRunConfigurationProfileState.kt

@@ -1,5 +1,7 @@
 package cc.unitmesh.devti.language.run
 
+import cc.unitmesh.devti.language.compiler.DevInCompiler
+import cc.unitmesh.devti.language.psi.DevInFile
 import com.intellij.build.process.BuildProcessHandler
 import com.intellij.execution.DefaultExecutionResult
 import com.intellij.execution.ExecutionException
@@ -14,6 +16,9 @@ import com.intellij.execution.runners.ProgramRunner
 import com.intellij.execution.ui.ConsoleView
 import com.intellij.execution.ui.ConsoleViewContentType
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.openapi.vfs.VirtualFileManager
+import com.intellij.psi.PsiManager
 import java.io.OutputStream
 
 open class DevInRunConfigurationProfileState(
@@ -25,10 +30,24 @@ open class DevInRunConfigurationProfileState(
         ProcessTerminatedListener.attach(processHandler)
 
         val console: ConsoleView = ConsoleViewWrapperBase(ConsoleViewImpl(myProject, true))
-
         console.attachToProcess(processHandler)
 
-        console.print("Hello, World!", ConsoleViewContentType.NORMAL_OUTPUT)
+        val file: DevInFile? = VirtualFileManager.getInstance()
+            .findFileByUrl("file://${configuration.getScriptPath()}")
+            ?.let {
+                PsiManager.getInstance(myProject).findFile(it)
+            } as? DevInFile
+
+        if (file == null) {
+            console.print("File not found: ${configuration.getScriptPath()}", ConsoleViewContentType.ERROR_OUTPUT)
+            processHandler.destroyProcess()
+            return DefaultExecutionResult(console, processHandler)
+        }
+
+        val compiler = DevInCompiler(myProject, file)
+        val output = compiler.compile()
+
+        console.print(output, ConsoleViewContentType.NORMAL_OUTPUT)
 
         // done!
         processHandler.detachProcess()