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

# Conflicts:
#	plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/AmazonQLanguageClientImpl.kt
#	plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/AmazonQLanguageClientImplTest.kt

Author: samgst-amazon

plugins/amazonq/chat/jetbrains-community/resources/META-INF/plugin-chat.xml

@@ -8,8 +8,6 @@
     <projectListeners>
         <listener class="software.aws.toolkits.jetbrains.services.amazonq.toolwindow.AmazonQToolWindowListener"
                   topic="com.intellij.openapi.wm.ex.ToolWindowManagerListener"/>
-        <listener class="software.aws.toolkits.jetbrains.services.amazonq.project.ProjectContextEditorListener"
-                  topic="com.intellij.openapi.fileEditor.FileEditorManagerListener"/>
     </projectListeners>
 
     <extensions defaultExtensionNs="com.intellij">

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/commands/MessageSerializer.kt

@@ -12,14 +12,15 @@ import com.fasterxml.jackson.databind.MapperFeature
 import com.fasterxml.jackson.databind.SerializationFeature
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.module.kotlin.treeToValue
 import org.jetbrains.annotations.VisibleForTesting
 import software.aws.toolkits.jetbrains.services.amazonq.messages.AmazonQMessage
 import software.aws.toolkits.jetbrains.services.amazonq.messages.UnknownMessageType
 import software.aws.toolkits.jetbrains.services.amazonq.util.command
 
 class MessageSerializer @VisibleForTesting constructor() {
 
-    private val objectMapper = jacksonObjectMapper()
+    val objectMapper = jacksonObjectMapper()
         .registerModule(JavaTimeModule())
         .enable(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS)
         .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
@@ -36,6 +37,9 @@ class MessageSerializer @VisibleForTesting constructor() {
 
     fun serialize(value: Any): String = objectMapper.writeValueAsString(value)
 
+    inline fun <reified T> deserializeChatMessages(value: JsonNode): T =
+        objectMapper.treeToValue<T>(value)
+
     // Provide singleton global access
     companion object {
         private val instance = MessageSerializer()

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

@@ -6,29 +6,20 @@ package software.aws.toolkits.jetbrains.services.amazonq.startup
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.runInEdt
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.project.waitForSmartMode
 import com.intellij.openapi.startup.ProjectActivity
 import com.intellij.openapi.wm.ToolWindowManager
-import kotlinx.coroutines.TimeoutCancellationException
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.time.withTimeout
-import software.aws.toolkits.core.utils.getLogger
-import software.aws.toolkits.core.utils.warn
 import software.aws.toolkits.jetbrains.core.credentials.AwsBearerTokenConnection
 import software.aws.toolkits.jetbrains.core.credentials.ToolkitConnectionManager
 import software.aws.toolkits.jetbrains.core.credentials.pinning.QConnection
 import software.aws.toolkits.jetbrains.core.gettingstarted.emitUserState
 import software.aws.toolkits.jetbrains.services.amazonq.CodeWhispererFeatureConfigService
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.AmazonQLspService
 import software.aws.toolkits.jetbrains.services.amazonq.profile.QRegionProfileManager
-import software.aws.toolkits.jetbrains.services.amazonq.project.ProjectContextController
 import software.aws.toolkits.jetbrains.services.amazonq.toolwindow.AmazonQToolWindow
 import software.aws.toolkits.jetbrains.services.amazonq.toolwindow.AmazonQToolWindowFactory
 import software.aws.toolkits.jetbrains.services.codewhisperer.explorer.CodeWhispererExplorerActionManager
 import software.aws.toolkits.jetbrains.services.cwc.inline.InlineChatController
 import software.aws.toolkits.jetbrains.settings.CodeWhispererSettings
-import java.lang.management.ManagementFactory
-import java.time.Duration
 import java.util.concurrent.atomic.AtomicBoolean
 
 class AmazonQStartupActivity : ProjectActivity {
@@ -58,39 +49,8 @@ class AmazonQStartupActivity : ProjectActivity {
         QRegionProfileManager.getInstance().validateProfile(project)
 
         AmazonQLspService.getInstance(project)
-        startLsp(project)
         if (runOnce.get()) return
         emitUserState(project)
         runOnce.set(true)
     }
-
-    private suspend fun startLsp(project: Project) {
-        // Automatically start the project context LSP after some delay when average CPU load is below 30%.
-        // The CPU load requirement is to avoid competing with native JetBrains indexing and other CPU expensive OS processes
-        // In the future we will decouple LSP start and indexing start to let LSP perform other tasks.
-        val startLspIndexingDuration = Duration.ofMinutes(30)
-        project.waitForSmartMode()
-        delay(30_000) // Wait for 30 seconds for systemLoadAverage to be more accurate
-        try {
-            withTimeout(startLspIndexingDuration) {
-                while (true) {
-                    val cpuUsage = ManagementFactory.getOperatingSystemMXBean().systemLoadAverage
-                    if (cpuUsage > 0 && cpuUsage < 30) {
-                        ProjectContextController.getInstance(project = project)
-                        break
-                    } else {
-                        delay(60_000) // Wait for 60 seconds
-                    }
-                }
-            }
-        } catch (e: TimeoutCancellationException) {
-            LOG.warn { "Failed to start LSP server due to time out" }
-        } catch (e: Exception) {
-            LOG.warn { "Failed to start LSP server" }
-        }
-    }
-
-    companion object {
-        private val LOG = getLogger<AmazonQStartupActivity>()
-    }
 }

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

@@ -5,23 +5,67 @@ package software.aws.toolkits.jetbrains.services.amazonq.toolwindow
 
 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.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.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.lsp.flareChat.FlareUiMessage
+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) {
+class AmazonQPanel(val project: Project, private val scope: CoroutineScope) : Disposable {
+    private val browser = CompletableFuture<Browser>()
     private val webviewContainer = Wrapper()
-    var browser: Browser? = null
-        private set
+    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(command: String) {
+                    browser.get()?.postChat(command)
+                }
+
+                override fun onChange(command: FlareUiMessage) {
+                    browser.get()?.postChat(command)
+                }
+            }
+        )
+    }
 
     val component = panel {
         row {
@@ -34,14 +78,12 @@ class AmazonQPanel(private val parent: Disposable) {
             row {
                 cell(
                     JButton("Show Web Debugger").apply {
-                        addActionListener(
-                            ActionListener {
-                                // Code to be executed when the button is clicked
-                                // Add your logic here
-
-                                browser?.jcefBrowser?.openDevtools()
-                            },
-                        )
+                        addActionListener {
+                            // Code to be executed when the button is clicked
+                            // Add your logic here
+
+                            browser.get().jcefBrowser.openDevtools()
+                        }
                     },
                 )
                     .align(AlignX.CENTER)
@@ -51,31 +93,114 @@ class AmazonQPanel(private val parent: Disposable) {
     }
 
     init {
-        init()
-    }
-
-    fun disposeAndRecreate() {
-        webviewContainer.removeAll()
-        val toDispose = browser
-        init()
-        if (toDispose != null) {
-            Disposer.dispose(toDispose)
-        }
-    }
-
-    private fun init() {
         if (!JBCefApp.isSupported()) {
             // Fallback to an alternative browser-less solution
             if (AppMode.isRemoteDevHost()) {
                 webviewContainer.add(JBTextArea("Amazon Q chat is not supported in remote dev environment."))
             } else {
                 webviewContainer.add(JBTextArea("JCEF not supported"))
             }
-            browser = null
+            browser.complete(null)
         } else {
-            browser = Browser(parent).also {
-                webviewContainer.add(it.component())
+            val loadingPanel = JBLoadingPanel(null, this)
+            val wrapper = Wrapper()
+            loadingPanel.startLoading()
+
+            webviewContainer.add(wrapper)
+            wrapper.setContent(loadingPanel)
+
+            ApplicationManager.getApplication().executeOnPooledThread {
+                val webUri = runBlocking { service<ArtifactManager>().fetchArtifact(project).resolve("amazonq-ui.js").toUri() }
+                loadingPanel.stopLoading()
+                runInEdt {
+                    browser.complete(
+                        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() {
+    }
 }