Merge pull request #20 from devchat-ai/conversation-history

Conversation history

Author: small-stone

.github/workflows/build.yml

@@ -37,8 +37,8 @@ jobs:
         uses: actions/checkout@v4
       - name: Get latest version of main.html and main.js
         run: |
-          wget $(curl -s https://api.github.com/repos/devchat-ai/devchat-plugins-frontend/releases/latest | grep -oP '"browser_download_url": "\K(.*)(?=")' | grep main.html) -O src/main/resources/static/main.html
-          wget $(curl -s https://api.github.com/repos/devchat-ai/devchat-plugins-frontend/releases/latest | grep -oP '"browser_download_url": "\K(.*)(?=")' | grep main.js) -O src/main/resources/static/main.js
+          wget $(curl -s https://api.github.com/repositories/709076669/releases/latest | grep -oP '"browser_download_url": "\K(.*)(?=")' | grep main.html) -O src/main/resources/static/main.html
+          wget $(curl -s https://api.github.com/repositories/709076669/releases/latest | grep -oP '"browser_download_url": "\K(.*)(?=")' | grep main.js) -O src/main/resources/static/main.js
 
       # Validate wrapper
       - name: Gradle Wrapper Validation

src/main/kotlin/ai/devchat/cli/DevChatResponse.kt

@@ -8,16 +8,13 @@ package ai.devchat.cli
  *
  * prompt 6e2a0d9b5c15eb33008250fee40383e77e8f80c75d9644b15bda60be256c8010
  */
-class DevChatResponse {
-    @JvmField
+class DevChatResponse(line: String) {
     var user: String? = null
-    @JvmField
     var date: String? = null
-    @JvmField
     var message: String? = null
-    @JvmField
     var promptHash: String? = null
-    fun populateFromLine(line: String) {
+
+    init {
         if (line.startsWith("User: ") && user == null) {
             user = line.substring("User: ".length)
         } else if (line.startsWith("Date: ") && date == null) {

src/main/kotlin/ai/devchat/cli/DevChatResponseConsumer.kt

@@ -3,20 +3,17 @@ package ai.devchat.cli
 import ai.devchat.common.Log
 import com.alibaba.fastjson.JSON
 import com.alibaba.fastjson.JSONArray
+import com.intellij.util.containers.addIfNotNull
 import java.io.BufferedReader
 import java.io.IOException
-import java.io.InputStream
-import java.io.InputStreamReader
-import java.util.*
-import java.util.function.BiConsumer
-import java.util.function.Consumer
+
+private const val DEFAULT_LOG_MAX_COUNT = 10000
 
 class DevChatWrapper {
     private var apiBase: String? = null
     private var apiKey: String? = null
     private var currentModel: String? = null
     private var command: String
-    private val DEFAULT_LOG_MAX_COUNT = "100"
 
     constructor(command: String) {
         this.command = command
@@ -29,23 +26,27 @@ class DevChatWrapper {
         this.command = command
     }
 
-    private fun execCommand(commands: List<String?>): String {
+    private fun execCommand(commands: List<String>, callback: ((String) -> Unit)?): String? {
         val pb = ProcessBuilder(commands)
-        if (apiBase != null) {
-            pb.environment()["OPENAI_API_BASE"] = apiBase
-            Log.info("api_base: $apiBase")
+        val env = pb.environment()
+
+        apiBase?.let {
+            env["OPENAI_API_BASE"] = it
+            Log.info("api_base: $it")
         }
-        if (apiKey != null) {
-            pb.environment()["OPENAI_API_KEY"] = apiKey
-            Log.info(
-                "api_key: " + apiKey!!.substring(0, 5) + "..."
-                        + apiKey!!.substring(apiKey!!.length - 4, apiKey!!.length)
-            )
+        apiKey?.let {
+            env["OPENAI_API_KEY"] = it
+            Log.info("api_key: ${it.substring(0, 5)}...${it.substring(it.length - 4)}")
         }
         return try {
-            Log.info("Executing command: " + java.lang.String.join(" ", pb.command()))
+            Log.info("Executing command: ${commands.joinToString(" ")}}")
             val process = pb.start()
-            val text = process.inputStream.bufferedReader().use(BufferedReader::readText)
+            val text = process.inputStream.bufferedReader().use { reader ->
+                callback?.let {
+                    reader.forEachLine(it)
+                    null
+                } ?: reader.readText()
+            }
             val errors = process.errorStream.bufferedReader().use(BufferedReader::readText)
             process.waitFor()
             val exitCode = process.exitValue()
@@ -67,143 +68,57 @@ class DevChatWrapper {
         }
     }
 
-    private fun execCommand(commands: List<String?>, callback: Consumer<String>) {
-        val pb = ProcessBuilder(commands)
-        if (apiBase != null) {
-            pb.environment()["OPENAI_API_BASE"] = apiBase
-            Log.info("api_base: $apiBase")
-        }
-        if (apiKey != null) {
-            pb.environment()["OPENAI_API_KEY"] = apiKey
-            Log.info(
-                "api_key: " + apiKey!!.substring(0, 5) + "..."
-                        + apiKey!!.substring(apiKey!!.length - 4, apiKey!!.length)
-            )
-        }
-        try {
-            Log.info("Executing command: " + java.lang.String.join(" ", pb.command()))
-            val process = pb.start()
-            readOutputByLine(process.inputStream, callback)
-            val exitCode = process.waitFor()
-            if (exitCode != 0) {
-                val error = readOutput(process.errorStream)
-                Log.error(
-                    "Failed to execute command: " + java.lang.String.join(" ", pb.command()) + " Exit Code: " + exitCode
-                            + " Error: " + error
-                )
-                throw RuntimeException(
-                    "Failed to execute command: " + java.lang.String.join(" ", pb.command()) + " Exit Code: " + exitCode
-                            + " Error: " + error
-                )
-            }
-        } catch (e: IOException) {
-            Log.error("Failed to execute command: " + java.lang.String.join(" ", pb.command()))
-            throw RuntimeException("Failed to execute command: " + java.lang.String.join(" ", pb.command()), e)
-        } catch (e: InterruptedException) {
-            Log.error("Failed to execute command: " + java.lang.String.join(" ", pb.command()))
-            throw RuntimeException("Failed to execute command: " + java.lang.String.join(" ", pb.command()), e)
-        }
+    val prompt: (MutableList<Pair<String, String?>>, String, ((String) -> Unit)?) -> Unit get() = {
+        flags: MutableList<Pair<String, String?>>, message: String, callback: ((String) -> Unit)? ->
+            flags.addAll(listOf("model" to currentModel, "" to message))
+            subCommand(listOf("prompt"))(flags, callback)
     }
 
-    @Throws(IOException::class)
-    private fun readOutput(inputStream: InputStream): String {
-        val reader = BufferedReader(InputStreamReader(inputStream))
-        val output = StringBuilder()
-        reader.forEachLine { line ->
-            output.append(line)
-            output.append('\n')
-        }
-        return output.toString()
+    val logTopic: (String, Int?) -> JSONArray get() = {topic: String, maxCount: Int? ->
+        val num: Int = maxCount ?: DEFAULT_LOG_MAX_COUNT
+        JSON.parseArray(log(mutableListOf(
+            "topic" to topic,
+            "max-count" to num.toString()
+        ), null))
     }
 
-    @Throws(IOException::class)
-    private fun readOutputByLine(inputStream: InputStream, callback: Consumer<String>) {
-        val reader = BufferedReader(InputStreamReader(inputStream))
-        reader.forEachLine { line -> callback.accept(line) }
-    }
+    val run get() = subCommand(listOf("run"))
+    val log get() = subCommand(listOf("log"))
+    val topic get() = subCommand(listOf("topic"))
 
-    fun runPromptCommand(flags: MutableMap<String, List<String?>>, message: String?, callback: Consumer<String>) {
-        try {
-            flags["model"] = listOf(currentModel)
-            val commands = prepareCommand("prompt", flags, message)
-            execCommand(commands, callback)
-        } catch (e: Exception) {
-            throw RuntimeException("Fail to run [prompt] command", e)
-        }
-    }
+    val topicList: JSONArray get() = JSON.parseArray(topic(mutableListOf("list" to null), null))
+    val commandList: JSONArray get() = JSON.parseArray(run(mutableListOf("list" to null), null))
 
-    fun runLogCommand(flags: Map<String, List<String?>>?): String {
-        return try {
-            val commands: List<String?> = prepareCommand(flags, "log")
-            execCommand(commands)
-        } catch (e: Exception) {
-            throw RuntimeException("Failed to run [log] command", e)
-        }
-    }
 
-    val commandList: JSONArray
-        get() {
-            val result = runCommand(null, "run", "--list")
-            return JSON.parseArray(result)
-        }
-    val commandNamesList: Array<String?>
-        get() {
-            val commandList = commandList
-            val names = arrayOfNulls<String>(commandList.size)
-            for (i in commandList.indices) {
-                names[i] = commandList.getJSONObject(i).getString("name")
-            }
-            return names
+    fun runCommand(subCommands: List<String>?, flags: List<Pair<String, String?>>? = null, callback: ((String) -> Unit)? = null): String? {
+        val cmd: MutableList<String> = mutableListOf(command)
+        cmd.addAll(subCommands.orEmpty())
+        flags?.forEach { (name, value) ->
+            cmd.add("--$name")
+            cmd.addIfNotNull(value)
         }
-
-    fun listConversationsInOneTopic(topicHash: String): JSONArray {
-        val result = runLogCommand(
-            java.util.Map.of<String, List<String?>>(
-                "topic", listOf(topicHash),
-                "max-count", listOf(DEFAULT_LOG_MAX_COUNT)
-            )
-        )
-        return JSON.parseArray(result)
-    }
-
-    fun listTopics(): JSONArray {
-        val result = runCommand(null, "topic", "--list")
-        return JSON.parseArray(result)
-    }
-
-    fun runCommand(flags: Map<String, List<String?>>?, vararg subCommands: String): String {
         return try {
-            val commands: List<String?> = prepareCommand(flags, *subCommands)
-            execCommand(commands)
+            execCommand(cmd, callback)
         } catch (e: Exception) {
-            Log.error("Failed to run [run] command: " + e.message)
-            throw RuntimeException("Failed to run [${subCommands}] command", e)
+            Log.error("Failed to run command $cmd: ${e.message}")
+            throw RuntimeException("Failed to run command $cmd", e)
         }
     }
 
-    private fun prepareCommand(flags: Map<String, List<String?>>?, vararg subCommands: String): MutableList<String?> {
-        val commands: MutableList<String?> = ArrayList()
-        commands.add(command)
-        Collections.addAll(commands, *subCommands)
-        if (flags == null) {
-            return commands
-        }
-        flags.forEach(BiConsumer { flag: String, values: List<String?> ->
-            for (value in values) {
-                commands.add("--$flag")
-                commands.add(value)
+    private fun subCommand(subCommands: List<String>): (MutableList<Pair<String, String?>>?, ((String) -> Unit)?) -> String? {
+        val cmd: MutableList<String> = mutableListOf(command)
+        cmd.addAll(subCommands)
+        return {flags: List<Pair<String, String?>>?, callback: ((String) -> Unit)? ->
+            flags?.forEach { (name, value) ->
+                cmd.add("--$name")
+                cmd.addIfNotNull(value)
+            }
+            try {
+                execCommand(cmd, callback)
+            } catch (e: Exception) {
+                Log.error("Failed to run command $cmd: ${e.message}")
+                throw RuntimeException("Failed to run command $cmd", e)
             }
-        })
-        return commands
-    }
-
-    private fun prepareCommand(subCommand: String, flags: Map<String, List<String?>>, message: String?): List<String?> {
-        val commands = prepareCommand(flags, subCommand)
-        // Add the message to the command list
-        if (!message.isNullOrEmpty()) {
-            commands.add("--")
-            commands.add(message)
         }
-        return commands
     }
 }

src/main/kotlin/ai/devchat/cli/DevChatWrapper.kt

@@ -12,7 +12,8 @@ class ActionHandlerFactory {
                 put(DevChatActions.SEND_MESSAGE_REQUEST, SendMessageRequestHandler::class)
                 put(DevChatActions.SET_OR_UPDATE_KEY_REQUEST, SetOrUpdateKeyRequestHandler::class)
                 put(DevChatActions.LIST_COMMANDS_REQUEST, ListCommandsRequestHandler::class)
-                put(DevChatActions.LIST_CONVERSATIONS_REQUEST, ListConversationsRequestHandler::class)
+                put(DevChatActions.LOAD_CONVERSATIONS_REQUEST, LoadConversationRequestHandler::class)
+                put(DevChatActions.LOAD_HISTORY_MESSAGES_REQUEST, LoadHistoryMessagesRequestHandler::class)
                 put(DevChatActions.LIST_TOPICS_REQUEST, ListTopicsRequestHandler::class)
                 put(DevChatActions.INSERT_CODE_REQUEST, InsertCodeRequestHandler::class)
                 put(DevChatActions.REPLACE_FILE_CONTENT_REQUEST, ReplaceFileContentHandler::class)

src/main/kotlin/ai/devchat/devchat/ActionHandlerFactory.kt

@@ -1,14 +1,17 @@
 package ai.devchat.devchat
 
+import ai.devchat.cli.DevChatWrapper
+import ai.devchat.common.DevChatPathUtil
+import ai.devchat.common.Log
 import com.alibaba.fastjson.JSONObject
 import com.intellij.openapi.project.Project
 import org.cef.browser.CefBrowser
-import java.util.function.BiConsumer
 
 /**
  * DevChatActionHandler class uses singleton pattern.
  */
 class DevChatActionHandler private constructor() {
+    val devChat: DevChatWrapper = DevChatWrapper(DevChatPathUtil.devchatBinPath)
     private var cefBrowser: CefBrowser? = null
     var project: Project? = null
         private set
@@ -17,15 +20,39 @@ class DevChatActionHandler private constructor() {
         this.cefBrowser = cefBrowser
         this.project = project
     }
+    fun handle(
+        action: String,
+        jsCallback: String,
+        callback: (JSONObject) -> Unit,
+    ) {
+        val response = JSONObject()
+        response["action"] = action
+        val metadata = JSONObject()
+        val payload = JSONObject()
+        response["metadata"] = metadata
+        response["payload"] = payload
+
+        try {
+            Log.info("Handling $action request")
+            callback(payload)
+            metadata["status"] = "success"
+            metadata["error"] = ""
+        } catch (e: Exception) {
+            Log.error("Exception occurred while handle action $action: ${e.message}")
+            metadata["status"] = "error"
+            metadata["error"] = e.message
+        }
+        cefBrowser!!.executeJavaScript("$jsCallback($response)", "", 0)
+    }
 
-    fun sendResponse(action: String, responseFunc: String, callback: BiConsumer<JSONObject, JSONObject>) {
+    fun sendResponse(action: String, responseFunc: String, callback: (JSONObject, JSONObject) -> Unit) {
         val response = JSONObject()
         response["action"] = action
         val metadata = JSONObject()
         val payload = JSONObject()
         response["metadata"] = metadata
         response["payload"] = payload
-        callback.accept(metadata, payload)
+        callback(metadata, payload)
         cefBrowser!!.executeJavaScript("$responseFunc($response)", "", 0)
     }
 

src/main/kotlin/ai/devchat/devchat/DevChatActionHandler.kt

@@ -10,8 +10,10 @@ object DevChatActions {
     const val ADD_CONTEXT_NOTIFY = "addContext/notify"
     const val LIST_COMMANDS_REQUEST = "listCommands/request"
     const val LIST_COMMANDS_RESPONSE = "listCommands/response"
-    const val LIST_CONVERSATIONS_REQUEST = "listConversations/request"
-    const val LIST_CONVERSATIONS_RESPONSE = "listConversations/response"
+    const val LOAD_CONVERSATIONS_REQUEST = "loadConversations/request"
+    const val LOAD_CONVERSATIONS_RESPONSE = "loadConversations/response"
+    const val LOAD_HISTORY_MESSAGES_REQUEST = "loadHistoryMessages/request"
+    const val LOAD_HISTORY_MESSAGES_RESPONSE = "loadHistoryMessages/response"
     const val LIST_TOPICS_REQUEST = "listTopics/request"
     const val LIST_TOPICS_RESPONSE = "listTopics/response"
     const val INSERT_CODE_REQUEST = "insertCode/request"

src/main/kotlin/ai/devchat/devchat/DevChatActions.kt

@@ -9,7 +9,6 @@ import java.io.BufferedReader
 import java.io.File
 import java.io.IOException
 import java.io.InputStreamReader
-import java.util.function.BiConsumer
 
 class CommitCodeRequestHandler(private val devChatActionHandler: DevChatActionHandler) : ActionHandler {
     private var metadata: JSONObject? = null
@@ -54,7 +53,7 @@ class CommitCodeRequestHandler(private val devChatActionHandler: DevChatActionHa
                 }
             }
         }
-        val processCommitResponse = BiConsumer { metadata: JSONObject, payload: JSONObject ->
+        val processCommitResponse = { metadata: JSONObject, payload: JSONObject ->
             if (error.isEmpty()) {
                 metadata["status"] = "success"
                 metadata["error"] = ""