feat(amazonq): Agentic coding experience

.changes/next-release/bugfix-061149bd-c6ef-4c86-9f12-98e38fe3b576.json

@@ -0,0 +1,4 @@
+{
+  "type" : "bugfix",
+  "description" : "Support full Unicode range in inline chat panel on Windows"
+}

.changes/next-release/feature-f8a047df-70ed-4c42-b9f7-f3b97e9c9a6e.json

@@ -0,0 +1,4 @@
+{
+  "type" : "feature",
+  "description" : "Agentic coding experience: Amazon Q can now write code and run shell commands on your behalf"
+}

buildSrc/src/main/kotlin/temp-toolkit-intellij-root-conventions.gradle.kts

@@ -35,7 +35,7 @@ val toolkitVersion: String by project
 
 // please check changelog generation logic if this format is changed
 // also sync with gateway version
-version = "$toolkitVersion-${ideProfile.shortName}"
+version = "$toolkitVersion.${ideProfile.shortName}"
 
 val resharperDlls = configurations.register("resharperDlls") {
     isCanBeConsumed = false

buildSrc/src/main/kotlin/toolkit-publishing-conventions.gradle.kts

@@ -16,7 +16,7 @@ val ideProfile = IdeVersions.ideProfile(project)
 val toolkitVersion: String by project
 
 // please check changelog generation logic if this format is changed
-version = "$toolkitVersion-${ideProfile.shortName}"
+version = "$toolkitVersion.${ideProfile.shortName}"
 
 // attach the current commit hash on local builds
 if (!project.isCi()) {

plugins/amazonq/build.gradle.kts

@@ -1,17 +1,24 @@
 // Copyright 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import org.jetbrains.intellij.platform.gradle.IntelliJPlatformType
+import com.fasterxml.jackson.databind.DeserializationFeature
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import de.undercouch.gradle.tasks.download.Download
+import org.jetbrains.intellij.platform.gradle.tasks.PrepareSandboxTask
 import software.aws.toolkits.gradle.changelog.tasks.GeneratePluginChangeLog
-import software.aws.toolkits.gradle.intellij.IdeFlavor
-import software.aws.toolkits.gradle.intellij.IdeVersions
-import software.aws.toolkits.gradle.intellij.toolkitIntelliJ
 
 plugins {
     id("toolkit-publishing-conventions")
     id("toolkit-publish-root-conventions")
     id("toolkit-jvm-conventions")
     id("toolkit-testing")
+    id("de.undercouch.download")
+}
+
+buildscript {
+    dependencies {
+        classpath(libs.bundles.jackson)
+    }
 }
 
 val changelog = tasks.register<GeneratePluginChangeLog>("pluginChangeLog") {
@@ -51,3 +58,81 @@ tasks.check {
         }
     }
 }
+
+val downloadFlareManifest by tasks.registering(Download::class) {
+    src("https://aws-toolkit-language-servers.amazonaws.com/qAgenticChatServer/0/manifest.json")
+    dest(layout.buildDirectory.file("flare/manifest.json"))
+    onlyIfModified(true)
+    useETag(true)
+}
+
+data class FlareManifest(
+    val versions: List<FlareVersion>,
+)
+
+data class FlareVersion(
+    val serverVersion: String,
+    val thirdPartyLicenses: String,
+    val targets: List<FlareTarget>,
+)
+
+data class FlareTarget(
+    val platform: String,
+    val arch: String,
+    val contents: List<FlareContent>
+)
+
+data class FlareContent(
+    val url: String,
+)
+
+val downloadFlareArtifacts by tasks.registering(Download::class) {
+    dependsOn(downloadFlareManifest)
+    inputs.files(downloadFlareManifest)
+
+    val manifestFile = downloadFlareManifest.map { it.outputFiles.first() }
+    val manifest = manifestFile.map { jacksonObjectMapper().disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES).readValue(it.readText(), FlareManifest::class.java) }
+
+    // use darwin-aarch64 because its the smallest and we're going to throw away everything platform specific
+    val latest = manifest.map { it.versions.first() }
+    val latestVersion = latest.map { it.serverVersion }
+    val licensesUrl = latest.map { it.thirdPartyLicenses }
+    val darwin = latest.map { it.targets.first { target -> target.platform == "darwin" && target.arch == "arm64" } }
+    val contentUrls = darwin.map { it.contents.map { content -> content.url } }
+
+    val destination = layout.buildDirectory.dir(latestVersion.map { "flare/$it" })
+    outputs.dir(destination)
+
+    src(contentUrls.zip(licensesUrl) { left, right -> left + right})
+    dest(destination)
+    onlyIfModified(true)
+    useETag(true)
+}
+
+val prepareBundledFlare by tasks.registering(Copy::class) {
+    dependsOn(downloadFlareArtifacts)
+    inputs.files(downloadFlareArtifacts)
+
+    val dest = layout.buildDirectory.dir("tmp/extractFlare")
+    into(dest)
+    from(downloadFlareArtifacts.map { it.outputFiles.filterNot { file -> file.name.endsWith(".zip") } })
+
+    doLast {
+        copy {
+            into(dest)
+            includeEmptyDirs = false
+            downloadFlareArtifacts.get().outputFiles.filter { it.name.endsWith(".zip") }.forEach {
+                dest.get().file(it.parentFile.name).asFile.createNewFile()
+                from(zipTree(it)) {
+                    include("*.js")
+                    include("*.txt")
+                }
+            }
+        }
+    }
+}
+
+tasks.withType<PrepareSandboxTask>().configureEach {
+    intoChild(intellijPlatform.projectName.map { "$it/flare" })
+        .from(prepareBundledFlare)
+}

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.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.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.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 @@
         } 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/QRefreshPanelAction.kt

@@ -11,7 +11,6 @@ import com.intellij.openapi.project.DumbAwareAction
 import com.intellij.util.messages.Topic
 import software.aws.toolkits.jetbrains.services.amazonq.toolwindow.AmazonQToolWindow
 import software.aws.toolkits.resources.AmazonQBundle
-import software.aws.toolkits.resources.message
 import java.util.EventListener
 
 class QRefreshPanelAction : DumbAwareAction(AmazonQBundle.message("amazonq.refresh.panel"), null, AllIcons.Actions.Refresh) {

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

@@ -12,14 +12,15 @@
 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,12 @@
 
     fun serialize(value: Any): String = objectMapper.writeValueAsString(value)
 
+    inline fun <reified T> deserializeChatMessages(value: JsonNode): T =
+        objectMapper.treeToValue<T>(value)
+
+    inline fun <reified T> deserializeChatMessages(value: JsonNode, clazz: Class<T>): T =
+        objectMapper.treeToValue(value, clazz)
+
     // 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>()
-    }
 }