WIP: Shared chat lib

.github/workflows/build.yml

@@ -35,6 +35,18 @@ jobs:
         run: |
           echo "lsp_version=$(cat refact_lsp)" >> $GITHUB_OUTPUT
 
+      - name: Download refact-chat-js
+        id: download-refact-chat-js
+        uses: dawidd6/action-download-artifact@v3
+        with:
+          github_token: ${{secrets.GITHUB_TOKEN}}
+          workflow: node.js.yml
+          workflow_search: true
+          repo: smallcloudai/refact-chat-js
+          branch: alpha
+          name: refact-chat-js-latest
+          path: ./src/main/resources/webview/dist
+
       - uses: convictional/[email protected]
         name: "Build refact-lsp"
         with:
@@ -54,6 +66,7 @@ jobs:
           branch: ${{ steps.setupvars.outputs.lsp_version }}
           path: ./src/main/resources/bin
 
+
       # Validate wrapper
       - name: Gradle Wrapper Validation
         uses: gradle/wrapper-validation-action@v3

.gitignore

@@ -38,4 +38,5 @@ bin/
 ### Mac OS ###
 .DS_Store
 
-src/main/resources/bin/
+src/main/resources/bin/
+src/main/resources/webview/dist

build.gradle.kts

@@ -15,19 +15,23 @@ dependencies {
     implementation("org.jetbrains.kotlin:kotlin-reflect:1.8.10")
     implementation("com.vladsch.flexmark:flexmark-all:0.64.8")
     implementation("io.github.kezhenxu94:cache-lite:0.2.0")
+
+    // test libraries
+    testImplementation(kotlin("test"))
 }
 
 
+
 group = "com.smallcloud"
-version = getVersionString("1.2.25")
+version = getVersionString("1.3.0")
 
 repositories {
     mavenCentral()
 }
 
 
 // Configure Gradle IntelliJ Plugin
-// Read more: https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html
+// Read more: https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html#intellij-extension-type
 intellij {
 //    version.set("LATEST-EAP-SNAPSHOT")
     version.set("2022.3.1")
@@ -65,6 +69,10 @@ tasks {
         channels.set(listOf(System.getenv("PUBLISH_CHANNEL")))
         token.set(System.getenv("PUBLISH_TOKEN"))
     }
+
+    test  {
+        useJUnitPlatform()
+    }
 }
 
 fun String.runCommand(

refact_lsp

@@ -1 +1 @@
-v0.8.0
+v0.8.2

src/main/kotlin/com/smallcloud/refactai/io/AsyncConnection.kt

@@ -152,6 +152,7 @@ class AsyncConnection : Disposable {
         failedDataReceiveEnded: (Throwable?) -> Unit = {},
         requestId: String = ""
     ): CompletableFuture<Future<*>> {
+        var canceled = false;
         return CompletableFuture.supplyAsync {
             return@supplyAsync client.execute(
                 requestProducer,
@@ -173,6 +174,8 @@ class AsyncConnection : Disposable {
 
                     override fun data(src: ByteBuffer?, endOfStream: Boolean) {
                         src ?: return
+                        if(canceled) return;
+
                         val part = Charset.forName("UTF-8").decode(src)
                         bufferStr += part
                         if (part.startsWith(STREAMING_PREFIX)) {
@@ -223,7 +226,11 @@ class AsyncConnection : Disposable {
                         failedDataReceiveEnded(ex)
                     }
 
-                    override fun cancelled() {}
+                    override fun cancelled() {
+                        // TODO: figure out how to stop the stream fro the lsp
+                        canceled = true
+                        dataReceiveEnded("Canceled")
+                    }
                 }
             )
         }
@@ -253,4 +260,5 @@ class AsyncConnection : Disposable {
     override fun dispose() {
         client.close()
     }
+
 }

src/main/kotlin/com/smallcloud/refactai/io/InferenceGlobalContext.kt

@@ -97,7 +97,7 @@ class InferenceGlobalContext : Disposable {
         get() {
             return AppSettingsState.inferenceUri?.let { URI(it) }
         }
-    
+
 
     var isNewChatStyle: Boolean = false
 

src/main/kotlin/com/smallcloud/refactai/lsp/LSPProcessHolder.kt

@@ -1,6 +1,7 @@
 package com.smallcloud.refactai.lsp
 
 import com.google.gson.Gson
+import com.google.gson.JsonObject
 import com.intellij.execution.configurations.GeneralCommandLine
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationInfo
@@ -16,18 +17,20 @@ import com.intellij.util.messages.MessageBus
 import com.intellij.util.messages.Topic
 import com.smallcloud.refactai.Resources
 import com.smallcloud.refactai.Resources.binPrefix
-import com.smallcloud.refactai.account.AccountManager.Companion.instance
 import com.smallcloud.refactai.account.AccountManagerChangedNotifier
 import com.smallcloud.refactai.io.InferenceGlobalContextChangedNotifier
 import com.smallcloud.refactai.notifications.emitError
+import com.smallcloud.refactai.panes.sharedchat.*
 import org.apache.hc.core5.concurrent.ComplexFuture
 import java.net.URI
 import java.nio.file.Files
 import java.nio.file.Paths
 import java.nio.file.StandardCopyOption
+import java.util.concurrent.CompletableFuture
 import java.util.concurrent.Future
 import java.util.concurrent.TimeUnit
 import kotlin.io.path.Path
+import com.smallcloud.refactai.account.AccountManager.Companion.instance as AccountManager
 import com.smallcloud.refactai.io.InferenceGlobalContext.Companion.instance as InferenceGlobalContext
 
 
@@ -159,7 +162,7 @@ class LSPProcessHolder(val project: Project): Disposable {
             InferenceGlobalContext.inferenceUri
         val newConfig = LSPConfig(
             address = address,
-            apiKey = instance.apiKey,
+            apiKey = AccountManager.apiKey,
             port = 0,
             clientVersion = "${Resources.client}-${Resources.version}/${Resources.jbBuildVersion}",
             useTelemetry = true,
@@ -246,6 +249,7 @@ class LSPProcessHolder(val project: Project): Disposable {
         private val BIN_PATH = Path(getTempDirectory(),
             ApplicationInfo.getInstance().build.toString().replace(Regex("[^A-Za-z0-9 ]"), "_") +
             "_refact_lsp${getExeSuffix()}").toString()
+        // here ?
         @JvmStatic
         fun getInstance(project: Project): LSPProcessHolder = project.service()
 
@@ -288,7 +292,7 @@ class LSPProcessHolder(val project: Project): Disposable {
             try {
                 requestFuture = it.get() as ComplexFuture
                 val out = requestFuture.get()
-                logger.warn("LSP caps_received " + out)
+                // logger.warn("LSP caps_received " + out)
                 val gson = Gson()
                 res = gson.fromJson(out as String, LSPCapabilities::class.java)
                 logger.debug("caps_received request finished")
@@ -298,4 +302,116 @@ class LSPProcessHolder(val project: Project): Disposable {
             return res
         }
     }
+
+    fun fetchCaps(): Future<LSPCapabilities> {
+//        // This causes the ide to crash :/
+//        if(this.capabilities.codeChatModels.isNotEmpty()) {
+//            println("caps_cached")
+//            return FutureTask { this.capabilities }
+//        }
+
+         val res = InferenceGlobalContext.connection.get(
+            url.resolve("/v1/caps"),
+            dataReceiveEnded = {},
+            errorDataReceived = {}
+        )
+
+        return res.thenApply {
+            val body = it.get() as String
+            val caps = Gson().fromJson(body, LSPCapabilities::class.java)
+            caps
+        }
+    }
+
+    fun fetchSystemPrompts(): Future<SystemPromptMap> {
+        val res = InferenceGlobalContext.connection.get(
+            url.resolve("/v1/customization"),
+            dataReceiveEnded = {},
+            errorDataReceived = {}
+        )
+        val json = res.thenApply {
+            val body = it.get() as String
+            val prompts = Gson().fromJson<CustomPromptsResponse>(body, CustomPromptsResponse::class.java)
+            prompts.systemPrompts
+        }
+
+        return json
+    }
+
+    fun fetchCommandCompletion(query: String, cursor: Int, count: Int = 5): Future<CommandCompletionResponse> {
+
+        val requestBody = Gson().toJson(mapOf("query" to query, "cursor" to cursor, "top_n" to count))
+
+        val res = InferenceGlobalContext.connection.post(
+            url.resolve("/v1/at-command-completion"),
+            requestBody,
+        )
+        // TODO: could this have a detail message?
+        val json = res.thenApply {
+            val body = it.get() as String
+            // handle error
+            // if(body.startsWith("detail"))
+            Gson().fromJson<CommandCompletionResponse>(body, CommandCompletionResponse::class.java)
+        }
+
+        return json
+    }
+
+    fun fetchCommandPreview(query: String): Future<Events.AtCommands.Preview.Response> {
+        val requestBody = Gson().toJson(mapOf("query" to query))
+
+        val response = InferenceGlobalContext.connection.post(
+            url.resolve("/v1/at-command-preview"),
+            requestBody
+        )
+
+        val json: Future<Events.AtCommands.Preview.Response> = response.thenApply {
+            val responseBody = it.get() as String
+            if (responseBody.startsWith("detail")) {
+                Events.AtCommands.Preview.Response(emptyArray())
+            } else {
+                Events.gson.fromJson(responseBody, Events.AtCommands.Preview.Response::class.java)
+            }
+        }
+
+        return json
+    }
+
+    fun sendChat(
+        id: String,
+        messages: ChatMessages,
+        model: String,
+        dataReceived: (String, String) -> Unit,
+        dataReceiveEnded: (String) -> Unit,
+        errorDataReceived: (JsonObject) -> Unit,
+        failedDataReceiveEnded: (Throwable?) -> Unit,
+    ): CompletableFuture<Future<*>> {
+
+        val parameters = mapOf("max_new_tokens" to 1000)
+
+        val requestBody = Gson().toJson(mapOf(
+            "messages" to messages.map {
+                val content = if(it.content is String) { it.content } else { Gson().toJson(it.content) }
+                mapOf("role" to it.role, "content" to content)
+            },
+            "model" to model,
+            "parameters" to parameters,
+            "stream" to true
+        ))
+
+        val headers = mapOf("Authorization" to "Bearer ${AccountManager.apiKey}")
+        val request = InferenceGlobalContext.connection.post(
+            url.resolve("/v1/chat"),
+            requestBody,
+            headers = headers,
+            dataReceived = dataReceived,
+            dataReceiveEnded = dataReceiveEnded,
+            errorDataReceived = errorDataReceived,
+            failedDataReceiveEnded = failedDataReceiveEnded,
+            requestId = id,
+        )
+
+         return request
+
+    }
 }

src/main/kotlin/com/smallcloud/refactai/panes/RefactAIToolboxPaneFactory.kt

@@ -7,30 +7,74 @@ import com.intellij.openapi.wm.ToolWindowFactory
 import com.intellij.openapi.wm.ToolWindowManager
 import com.intellij.ui.content.Content
 import com.intellij.ui.content.ContentFactory
+import com.intellij.ui.jcef.JBCefApp
 import com.smallcloud.refactai.Resources
 import com.smallcloud.refactai.panes.gptchat.ChatGPTPanes
+import com.smallcloud.refactai.panes.sharedchat.ChatPanes
 import com.smallcloud.refactai.utils.getLastUsedProject
 
+
 class RefactAIToolboxPaneFactory : ToolWindowFactory {
     override fun init(toolWindow: ToolWindow) {
         toolWindow.setIcon(Resources.Icons.LOGO_RED_13x13)
         super.init(toolWindow)
     }
 
+    override fun isApplicable(project: Project): Boolean {
+        return try {
+            JBCefApp.isSupported() && JBCefApp.isStarted()
+            JBCefApp.isSupported()
+        } catch (_: Exception) {
+            false
+        }
+    }
+
+
     override fun createToolWindowContent(project: Project, toolWindow: ToolWindow) {
         val contentFactory = ContentFactory.getInstance()
 
-        val gptChatPanes = ChatGPTPanes(project, toolWindow.disposable)
-        val content: Content = contentFactory.createContent(
-                gptChatPanes.getComponent(),
-                "Chat",
-                false
-        )
+//        val gptChatPanes = ChatGPTPanes(project, toolWindow.disposable)
+//        val content: Content = contentFactory.createContent(
+//                gptChatPanes.getComponent(),
+//                "Chat",
+//                false
+//        )
+//        content.isCloseable = false
+//        content.putUserData(panesKey, gptChatPanes)
+//        toolWindow.contentManager.addContent(content)
+
+        val chatPanes = ChatPanes(project, toolWindow.disposable)
+        val content: Content = contentFactory.createContent(chatPanes.getComponent(), "Chat", false)
         content.isCloseable = false
-        content.putUserData(panesKey, gptChatPanes)
         toolWindow.contentManager.addContent(content)
+
+//        val sp = SharedChatPane(project)
+//
+//        val chatIframeContent: Content = contentFactory.createContent(
+//            sp.getComponent(),
+//            "Shared Chat",
+//            false
+//        )
+//        chatIframeContent.isCloseable = false
+//
+//        toolWindow.contentManager.addContent(chatIframeContent)
+
+
+        // Uncomment to enable dev tools
+//        val devToolsBrowser = JBCefBrowser.createBuilder()
+//            .setCefBrowser(sp.webView.cefBrowser.devTools)
+//            .setClient(sp.webView.jbCefClient)
+//            .build();
+//
+//        val c = contentFactory.createContent(devToolsBrowser.component, "Shared Chat Dev", false)
+//        toolWindow.contentManager.addContent(c)
+//        devToolsBrowser.openDevtools()
+
+
     }
 
+
+
     companion object {
         private val panesKey = Key.create<ChatGPTPanes>("refact.panes")
         val chat: ChatGPTPanes?