Merge branch 'feature/q-lsp-chat' into q-lsp-chat

Author: andrewyuq

.changes/next-release/bugfix-7e09465d-6cb8-4180-9131-7ec6543db20c.json

@@ -0,0 +1,4 @@
+{
+  "type" : "bugfix",
+  "description" : "increase /review timeout"
+}

buildSrc/src/main/kotlin/software/aws/toolkits/gradle/intellij/IdeVersions.kt

@@ -103,40 +103,40 @@ object IdeVersions {
         Profile(
             name = "2025.1",
             gateway = ProductProfile(
-                sdkVersion = "251.23774-EAP-CANDIDATE-SNAPSHOT",
+                sdkVersion = "251.23774.441-CUSTOM-SNAPSHOT",
                 bundledPlugins = listOf("org.jetbrains.plugins.terminal")
             ),
             community = ProductProfile(
-                sdkVersion = "251.23774.109-EAP-SNAPSHOT",
+                sdkVersion = "2025.1",
                 bundledPlugins = commonPlugins + listOf(
                     "com.intellij.java",
                     "com.intellij.gradle",
                     "org.jetbrains.idea.maven",
                 ),
                 marketplacePlugins = listOf(
-                    "PythonCore:251.23774.109",
-                    "Docker:251.23774.109"
+                    "PythonCore:251.23774.460",
+                    "Docker:251.23774.466"
                 )
             ),
             ultimate = ProductProfile(
-                sdkVersion = "251.23774.109-EAP-SNAPSHOT",
+                sdkVersion = "2025.1",
                 bundledPlugins = commonPlugins + listOf(
                     "JavaScript",
                     "JavaScriptDebugger",
                     "com.intellij.database",
                     "com.jetbrains.codeWithMe",
                 ),
                 marketplacePlugins = listOf(
-                    "Pythonid:251.23774.109",
-                    "org.jetbrains.plugins.go:251.23774.109",
+                    "Pythonid:251.23774.460",
+                    "org.jetbrains.plugins.go:251.23774.435",
                 )
             ),
             rider = RiderProfile(
-                sdkVersion = "2025.1-EAP8-SNAPSHOT",
+                sdkVersion = "2025.1",
                 bundledPlugins = commonPlugins,
                 netFrameworkTarget = "net472",
                 rdGenVersion = "2025.1.1",
-                nugetVersion = " 2025.1.0-eap08"
+                nugetVersion = " 2025.1.0"
             )
         ),
     ).associateBy { it.name }

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/QLoginWebview.kt

@@ -18,6 +18,10 @@ import com.intellij.ui.components.panels.Wrapper
 import com.intellij.ui.dsl.builder.Align
 import com.intellij.ui.dsl.builder.panel
 import com.intellij.ui.jcef.JBCefJSQuery
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
 import org.cef.CefApp
 import software.aws.toolkits.core.utils.debug
 import software.aws.toolkits.core.utils.error
@@ -40,6 +44,8 @@ import software.aws.toolkits.jetbrains.services.amazonq.profile.QProfileSwitchIn
 import software.aws.toolkits.jetbrains.services.amazonq.profile.QRegionProfile
 import software.aws.toolkits.jetbrains.services.amazonq.profile.QRegionProfileManager
 import software.aws.toolkits.jetbrains.services.amazonq.util.createBrowser
+import software.aws.toolkits.jetbrains.services.amazonq.webview.theme.EditorThemeAdapter
+import software.aws.toolkits.jetbrains.services.amazonq.webview.theme.ThemeBrowserAdapter
 import software.aws.toolkits.jetbrains.utils.isQConnected
 import software.aws.toolkits.jetbrains.utils.isQExpired
 import software.aws.toolkits.jetbrains.utils.isQWebviewsAvailable
@@ -54,7 +60,7 @@ import javax.swing.JButton
 import javax.swing.JComponent
 
 @Service(Service.Level.PROJECT)
-class QWebviewPanel private constructor(val project: Project) : Disposable {
+class QWebviewPanel private constructor(val project: Project, private val scope: CoroutineScope) : Disposable {
     private val webviewContainer = Wrapper()
     var browser: QWebviewBrowser? = null
         private set
@@ -102,6 +108,14 @@ class QWebviewPanel private constructor(val project: Project) : Disposable {
         } else {
             browser = QWebviewBrowser(project, this).also {
                 webviewContainer.add(it.component())
+
+                val themeBrowserAdapter = ThemeBrowserAdapter()
+                EditorThemeAdapter().onThemeChange()
+                    .distinctUntilChanged()
+                    .onEach { theme ->
+                        themeBrowserAdapter.updateLoginThemeInBrowser(it.jcefBrowser.cefBrowser, theme)
+                    }
+                    .launchIn(scope)
             }
         }
     }

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/toolwindow/AmazonQPanel.kt

@@ -7,27 +7,62 @@ import com.intellij.idea.AppMode
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.runInEdt
+import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
 import com.intellij.ui.components.JBLoadingPanel
-import com.intellij.ui.components.JBPanelWithEmptyText
 import com.intellij.ui.components.JBTextArea
 import com.intellij.ui.components.panels.Wrapper
 import com.intellij.ui.dsl.builder.Align
 import com.intellij.ui.dsl.builder.AlignX
 import com.intellij.ui.dsl.builder.AlignY
 import com.intellij.ui.dsl.builder.panel
 import com.intellij.ui.jcef.JBCefApp
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import software.aws.toolkits.jetbrains.isDeveloperMode
-import software.aws.toolkits.jetbrains.services.amazonq.lsp.artifacts.ArtifactHelper
+import software.aws.toolkits.jetbrains.services.amazonq.apps.AmazonQAppInitContext
+import software.aws.toolkits.jetbrains.services.amazonq.apps.AppConnection
+import software.aws.toolkits.jetbrains.services.amazonq.commands.MessageTypeRegistry
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.artifacts.ArtifactManager
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.AsyncChatUiListener
+import software.aws.toolkits.jetbrains.services.amazonq.messages.AmazonQMessage
+import software.aws.toolkits.jetbrains.services.amazonq.messages.MessageConnector
+import software.aws.toolkits.jetbrains.services.amazonq.profile.QRegionProfileManager
+import software.aws.toolkits.jetbrains.services.amazonq.util.highlightCommand
 import software.aws.toolkits.jetbrains.services.amazonq.webview.Browser
-import java.awt.event.ActionListener
+import software.aws.toolkits.jetbrains.services.amazonq.webview.BrowserConnector
+import software.aws.toolkits.jetbrains.services.amazonq.webview.FqnWebviewAdapter
+import software.aws.toolkits.jetbrains.services.amazonq.webview.theme.EditorThemeAdapter
+import software.aws.toolkits.jetbrains.services.amazonqCodeScan.auth.isCodeScanAvailable
+import software.aws.toolkits.jetbrains.services.amazonqCodeTest.auth.isCodeTestAvailable
+import software.aws.toolkits.jetbrains.services.amazonqDoc.auth.isDocAvailable
+import software.aws.toolkits.jetbrains.services.amazonqFeatureDev.auth.isFeatureDevAvailable
+import software.aws.toolkits.jetbrains.services.codemodernizer.utils.isCodeTransformAvailable
 import java.util.concurrent.CompletableFuture
 import javax.swing.JButton
 
-class AmazonQPanel(private val parent: Disposable, val project: Project) {
+class AmazonQPanel(val project: Project, private val scope: CoroutineScope) : Disposable {
+    private val browser = CompletableFuture<Browser>()
     private val webviewContainer = Wrapper()
-    val browser = CompletableFuture<Browser>()
+    private val appSource = AppSource()
+    private val browserConnector = BrowserConnector(project = project)
+    private val editorThemeAdapter = EditorThemeAdapter()
+    private val appConnections = mutableListOf<AppConnection>()
+
+    init {
+        project.messageBus.connect().subscribe(
+            AsyncChatUiListener.TOPIC,
+            object : AsyncChatUiListener {
+                override fun onChange(message: String) {
+                    runInEdt {
+                        browser.get()?.postChat(message)
+                    }
+                }
+            }
+        )
+    }
 
     val component = panel {
         row {
@@ -40,14 +75,12 @@ class AmazonQPanel(private val parent: Disposable, val project: Project) {
             row {
                 cell(
                     JButton("Show Web Debugger").apply {
-                        addActionListener(
-                            ActionListener {
-                                // Code to be executed when the button is clicked
-                                // Add your logic here
-
-                                browser.get().jcefBrowser.openDevtools()
-                            },
-                        )
+                        addActionListener {
+                            // Code to be executed when the button is clicked
+                            // Add your logic here
+
+                            browser.get().jcefBrowser.openDevtools()
+                        }
                     },
                 )
                     .align(AlignX.CENTER)
@@ -57,19 +90,6 @@ class AmazonQPanel(private val parent: Disposable, val project: Project) {
     }
 
     init {
-        init()
-    }
-
-    fun disposeAndRecreate() {
-        webviewContainer.removeAll()
-        val toDispose = browser.get()
-        init()
-        if (toDispose != null) {
-            Disposer.dispose(toDispose)
-        }
-    }
-
-    private fun init() {
         if (!JBCefApp.isSupported()) {
             // Fallback to an alternative browser-less solution
             if (AppMode.isRemoteDevHost()) {
@@ -79,25 +99,105 @@ class AmazonQPanel(private val parent: Disposable, val project: Project) {
             }
             browser.complete(null)
         } else {
-            val loadingPanel = JBLoadingPanel(null, parent, 0)
+            val loadingPanel = JBLoadingPanel(null, this)
             val wrapper = Wrapper()
             loadingPanel.startLoading()
 
-            loadingPanel.add(JBPanelWithEmptyText().withEmptyText("Wait for chat to be ready"))
             webviewContainer.add(wrapper)
             wrapper.setContent(loadingPanel)
 
             ApplicationManager.getApplication().executeOnPooledThread {
-                val webUri = ArtifactHelper().getLatestLocalLspArtifact().resolve("amazonq-ui.js").toUri()
+                val webUri = runBlocking { service<ArtifactManager>().fetchArtifact(project).resolve("amazonq-ui.js").toUri() }
                 loadingPanel.stopLoading()
                 runInEdt {
                     browser.complete(
-                        Browser(parent, webUri, project).also {
+                        Browser(this, webUri, project).also {
                             wrapper.setContent(it.component())
+
+                            initConnections()
+                            connectUi(it)
+                            connectApps(it)
                         }
                     )
                 }
             }
         }
     }
+
+    fun sendMessage(message: AmazonQMessage, tabType: String) {
+        appConnections.filter { it.app.tabTypes.contains(tabType) }.forEach {
+            scope.launch {
+                it.messagesFromUiToApp.publish(message)
+            }
+        }
+    }
+
+    fun sendMessageAppToUi(message: AmazonQMessage, tabType: String) {
+        appConnections.filter { it.app.tabTypes.contains(tabType) }.forEach {
+            scope.launch {
+                it.messagesFromAppToUi.publish(message)
+            }
+        }
+    }
+
+    private fun initConnections() {
+        val apps = appSource.getApps(project)
+        apps.forEach { app ->
+            appConnections += AppConnection(
+                app = app,
+                messagesFromAppToUi = MessageConnector(),
+                messagesFromUiToApp = MessageConnector(),
+                messageTypeRegistry = MessageTypeRegistry(),
+            )
+        }
+    }
+
+    private fun connectApps(browser: Browser) {
+        val fqnWebviewAdapter = FqnWebviewAdapter(browser.jcefBrowser, browserConnector)
+
+        appConnections.forEach { connection ->
+            val initContext = AmazonQAppInitContext(
+                project = project,
+                messagesFromAppToUi = connection.messagesFromAppToUi,
+                messagesFromUiToApp = connection.messagesFromUiToApp,
+                messageTypeRegistry = connection.messageTypeRegistry,
+                fqnWebviewAdapter = fqnWebviewAdapter,
+            )
+            // Connect the app to the UI
+            connection.app.init(initContext)
+            // Dispose of the app when the tool window is disposed.
+            Disposer.register(this, connection.app)
+        }
+    }
+
+    private fun connectUi(browser: Browser) {
+        browser.init(
+            isCodeTransformAvailable = isCodeTransformAvailable(project),
+            isFeatureDevAvailable = isFeatureDevAvailable(project),
+            isCodeScanAvailable = isCodeScanAvailable(project),
+            isCodeTestAvailable = isCodeTestAvailable(project),
+            isDocAvailable = isDocAvailable(project),
+            highlightCommand = highlightCommand(),
+            activeProfile = QRegionProfileManager.getInstance().takeIf { it.shouldDisplayProfileInfo(project) }?.activeProfile(project)
+        )
+
+        scope.launch {
+            // Pipe messages from the UI to the relevant apps and vice versa
+            browserConnector.connect(
+                browser = browser,
+                connections = appConnections,
+            )
+        }
+
+        scope.launch {
+            // Update the theme in the UI when the IDE theme changes
+            browserConnector.connectTheme(
+                chatBrowser = browser.jcefBrowser.cefBrowser,
+                themeSource = editorThemeAdapter.onThemeChange(),
+            )
+        }
+    }
+
+    override fun dispose() {
+    }
 }