feat(amazonq): add support for CodeReview and DisplayFindings tools, alter behavior of explain and fix buttons

.changes/next-release/feature-fa373e43-dd37-4f6f-a226-7476f5866e9a.json

@@ -0,0 +1,4 @@
+{
+  "type" : "feature",
+  "description" : "Enable agentic code review"
+}

gradle/libs.versions.toml

@@ -28,7 +28,7 @@ mockitoKotlin = "5.4.1-SNAPSHOT"
 mockk = "1.13.17"
 nimbus-jose-jwt = "9.40"
 node-gradle = "7.0.2"
-telemetryGenerator = "1.0.322"
+telemetryGenerator = "1.0.329"
 testLogger = "4.0.0"
 testRetry = "1.5.10"
 # test-only; platform provides slf4j transitively at runtime

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

@@ -10,9 +10,13 @@
 import com.intellij.ide.BrowserUtil
 import com.intellij.ide.util.RunOnceUtil
 import com.intellij.openapi.application.runInEdt
+import com.intellij.openapi.application.runReadAction
+import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.openapi.fileEditor.FileEditorManager
 import com.intellij.openapi.options.ShowSettingsUtil
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.LocalFileSystem
+import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.ui.jcef.JBCefJSQuery.Response
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CompletableDeferred
@@ -71,6 +75,8 @@
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.CHAT_TAB_BAR_ACTIONS
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.CHAT_TAB_CHANGE
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.CHAT_TAB_REMOVE
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.CODE_REVIEW_FINDINGS_SUFFIX
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.DISPLAY_FINDINGS_SUFFIX
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.EncryptedChatParams
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.EncryptedQuickActionChatParams
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.GET_SERIALIZED_CHAT_REQUEST_METHOD
@@ -107,13 +113,21 @@
 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 software.aws.toolkits.jetbrains.services.codewhisperer.codescan.CodeWhispererCodeScanIssue
+import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.CodeWhispererCodeScanManager
+import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.Description
+import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.Recommendation
+import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.SuggestedFix
 import software.aws.toolkits.jetbrains.services.codewhisperer.settings.CodeWhispererConfigurable
+import software.aws.toolkits.jetbrains.services.codewhisperer.util.CodeWhispererConstants
 import software.aws.toolkits.jetbrains.settings.MeetQSettings
 import software.aws.toolkits.telemetry.MetricResult
 import software.aws.toolkits.telemetry.Telemetry
+import java.nio.file.Path
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.CompletionException
 import java.util.function.Function
+import kotlin.collections.get
 
 class BrowserConnector(
     private val serializer: MessageSerializer = MessageSerializer.getInstance(),
@@ -568,6 +582,32 @@
         }
     }
 
+    data class FlareCodeScanIssue(
+        val startLine: Int,
+        val endLine: Int,
+        val comment: String?,
+        val title: String,
+        val description: Description,
+        val detectorId: String,
+        val detectorName: String,
+        val findingId: String,
+        val ruleId: String?,
+        val relatedVulnerabilities: List<String>,
+        val severity: String,
+        val recommendation: Recommendation,
+        val suggestedFixes: List<SuggestedFix>,
+        val scanJobId: String,
+        val language: String,
+        val autoDetected: Boolean,
+        val filePath: String,
+        val findingContext: String,
+    )
+
+    data class AggregatedCodeScanIssue(
+        val filePath: String,
+        val issues: List<FlareCodeScanIssue>,
+    )
+
     private fun showResult(
         result: CompletableFuture<String>,
         partialResultToken: String,
@@ -581,10 +621,14 @@
                     throw error
                 }
                 chatCommunicationManager.removePartialChatMessage(partialResultToken)
+                val decryptedMessage = Gson().fromJson(value?.let { encryptionManager?.decrypt(it) }.orEmpty(), Map::class.java)
+                    as Map<String, *>
+                parseFindingsMessages(decryptedMessage)
+
                 val messageToChat = ChatCommunicationManager.convertToJsonToSendToChat(
                     SEND_CHAT_COMMAND_PROMPT,
                     tabId,
-                    value?.let { encryptionManager?.decrypt(it) }.orEmpty(),
+                    Gson().toJson(decryptedMessage),
                     isPartialResult = false
                 )
                 browser.postChat(messageToChat)
@@ -598,6 +642,85 @@
         }
     }
 
+    fun parseFindingsMessages(messagesMap: Map<String, *>) {
+        try {
+            val additionalMessages = messagesMap["additionalMessages"] as? MutableList<Map<String, Any>>
+            val findingsMessages = additionalMessages?.filter { message ->
+                if (message.contains("messageId")) {
+                    (message["messageId"] as String).endsWith(CODE_REVIEW_FINDINGS_SUFFIX) ||
+                        (message["messageId"] as String).endsWith(DISPLAY_FINDINGS_SUFFIX)
+                } else {
+                    false
+                }
+            }
+            val scannedFiles = mutableListOf<VirtualFile>()
+            if (findingsMessages != null) {
+                for (findingsMessage in findingsMessages) {
+                    additionalMessages.remove(findingsMessage)
+                    val gson = Gson()
+                    val jsonFindings = gson.fromJson(findingsMessage["body"] as String, List::class.java)
+                    val mappedFindings = mutableListOf<CodeWhispererCodeScanIssue>()
+                    for (aggregatedIssueUnformatted in jsonFindings) {
+                        val aggregatedIssue = gson.fromJson(gson.toJson(aggregatedIssueUnformatted), AggregatedCodeScanIssue::class.java)
+                        val file = LocalFileSystem.getInstance().findFileByIoFile(
+                            Path.of(aggregatedIssue.filePath).toFile()
+                        )
+                        if (file?.isDirectory == false) {
+                            scannedFiles.add(file)
+                            runReadAction {
+                                FileDocumentManager.getInstance().getDocument(file)
+                            }?.let { document ->
+                                for (issue in aggregatedIssue.issues) {
+                                    val endLineInDocument = minOf(maxOf(0, issue.endLine - 1), document.lineCount - 1)
+                                    val endCol = document.getLineEndOffset(endLineInDocument) - document.getLineStartOffset(endLineInDocument) + 1
+                                    val isIssueIgnored = CodeWhispererCodeScanManager.getInstance(project)
+                                        .isIgnoredIssue(issue.title, document, file, issue.startLine - 1)
+                                    if (isIssueIgnored) {
+                                        continue
+                                    }
+                                    mappedFindings.add(
+                                        CodeWhispererCodeScanIssue(
+                                            startLine = issue.startLine,
+                                            startCol = 1,
+                                            endLine = issue.endLine,
+                                            endCol = endCol,
+                                            file = file,
+                                            project = project,
+                                            title = issue.title,
+                                            description = issue.description,
+                                            detectorId = issue.detectorId,
+                                            detectorName = issue.detectorName,
+                                            findingId = issue.findingId,
+                                            ruleId = issue.ruleId,
+                                            relatedVulnerabilities = issue.relatedVulnerabilities,
+                                            severity = issue.severity,
+                                            recommendation = issue.recommendation,
+                                            suggestedFixes = issue.suggestedFixes,
+                                            codeSnippet = emptyList(),
+                                            isVisible = true,
+                                            autoDetected = issue.autoDetected,
+                                            scanJobId = issue.scanJobId,
+                                        ),
+                                    )
+                                }
+                            }
+                        }
+                    }
+
+                    CodeWhispererCodeScanManager.getInstance(project)
+                        .addOnDemandIssues(
+                            mappedFindings,
+                            scannedFiles,
+                            CodeWhispererConstants.CodeAnalysisScope.AGENTIC
+                        )
+                    CodeWhispererCodeScanManager.getInstance(project).showCodeScanUI()
+                }
+            }
+        } catch (e: Exception) {
+            LOG.error { "Failed to parse findings message $e" }
+        }
+    }
+
     private suspend fun updateQuickActionsInBrowser(browser: Browser) {
         val isFeatureDevAvailable = isFeatureDevAvailable(project)
         val isCodeTransformAvailable = isCodeTransformAvailable(project)

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

@@ -34,8 +34,8 @@ enum class EditorContextCommand(
         verb = "sendToPrompt",
         actionId = "aws.amazonq.sendToPrompt",
     ),
-    ExplainCodeScanIssue(
-        verb = "ExplainIssue",
-        actionId = "aws.amazonq.explainCodeScanIssue",
+    HandleCodeScanIssue(
+        verb = "HandleCodeScanIssue",
+        actionId = "aws.amazonq.handleCodeScanIssueCommand",
     ),
 }

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/commands/codescan/actions/ExplainCodeIssueAction.kt → plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/commands/codescan/actions/HandleIssueCommandAction.kt

@@ -17,34 +17,56 @@
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.SEND_TO_PROMPT
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.SendToPromptParams
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.TriggerType
+import software.aws.toolkits.jetbrains.services.cwc.controller.chat.telemetry.TelemetryHelper
+import software.aws.toolkits.jetbrains.services.cwc.controller.chat.telemetry.getStartUrl
+
+class HandleIssueCommandAction : AnAction(), DumbAware {
+    val contextDataKey = DataKey.create<MutableMap<String, String>>("amazonq.codescan.handleIssueCommandContext")
+    val actionDataKey = DataKey.create<String>("amazonq.codescan.handleIssueCommandAction")
 
-class ExplainCodeIssueAction : AnAction(), DumbAware {
     override fun getActionUpdateThread() = ActionUpdateThread.BGT
 
     override fun update(e: AnActionEvent) {
         e.presentation.isEnabledAndVisible = e.project != null
     }
+    fun createLineRangeText(issueContext: MutableMap<String, String>): String {
+        val startLine = issueContext["startLine"]
+        val endLine = issueContext["endLine"]
+        return if (startLine.equals(endLine)) {
+            "[$startLine]"
+        } else {
+            "[$startLine, $endLine]"
+        }
+    }
 
     override fun actionPerformed(e: AnActionEvent) {
         val project = e.project ?: return
-        val issueDataKey = DataKey.create<MutableMap<String, String>>("amazonq.codescan.explainissue")
-        val issueContext = e.getData(issueDataKey) ?: return
+        val context = e.getData(contextDataKey) ?: return
+        val action = e.getData(actionDataKey) ?: return
+
+        // Emit telemetry event
+        TelemetryHelper.recordTelemetryIssueCommandAction(
+            context["findingId"].orEmpty(),
+            context["detectorId"].orEmpty(),
+            context["ruleId"].orEmpty(),
+            context["autoDetected"].orEmpty(),
+            getStartUrl(project).orEmpty(),
+            action, // The action name (explainIssue or applyFix)
+            "Succeeded"
+        )
 
         ActionManager.getInstance().getAction("q.openchat").actionPerformed(e)
 
         ApplicationManager.getApplication().executeOnPooledThread {
             runBlocking {
                 // https://github.com/aws/aws-toolkit-vscode/blob/master/packages/amazonq/src/lsp/chat/commands.ts#L30
-                val codeSelection = "\n```\n${issueContext["code"]?.trimIndent()?.trim()}\n```\n"
+                val codeSelection = "\n```\n${context["code"]?.trimIndent()?.trim()}\n```\n"
+                val actionString = if (action == "explainIssue") "Explain" else "Fix"
 
-                val prompt = "Explain the issue \n\n " +
-                    "Issue:    \"${issueContext["title"]}\" \n" +
-                    "Code:    $codeSelection"
+                val prompt = "$actionString ${context["title"]} issue in ${context["fileName"]} at ${createLineRangeText(context)}"
 
-                val modelPrompt = "Explain the issue ${issueContext["title"]} \n\n " +
-                    "Issue:    \"${issueContext["title"]}\" \n" +
-                    "Description:    ${issueContext["description"]} \n" +
-                    "Code:    $codeSelection and generate the code demonstrating the fix"
+                val modelPrompt = "$actionString ${context["title"]} issue in ${context["fileName"]} at ${createLineRangeText(context)}" +
+                    "Issue: \"${context}\" \n"
 
                 val params = SendToPromptParams(
                     selection = codeSelection,

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/controller/chat/telemetry/TelemetryHelper.kt

@@ -441,6 +441,26 @@ class TelemetryHelper(private val project: Project, private val sessionStorage:
                     .credentialStartUrl(startUrl)
             }
         }
+
+        fun recordTelemetryIssueCommandAction(
+            findingId: String,
+            detectorId: String,
+            ruleId: String,
+            autoDetected: String,
+            startUrl: String,
+            metricName: String,
+            result: String,
+        ) {
+            Telemetry.amazonq.codeReviewTool.use {
+                it.reason(metricName)
+                    .setAttribute("findingId", findingId)
+                    .setAttribute("detectorId", detectorId)
+                    .setAttribute("ruleId", ruleId)
+                    .setAttribute("credentialStartUrl", startUrl)
+                    .setAttribute("autoDetected", autoDetected)
+                    .setAttribute("result", result)
+            }
+        }
     }
 }
 

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/controller/chat/userIntent/UserIntentRecognizer.kt

@@ -15,7 +15,7 @@ class UserIntentRecognizer {
         EditorContextCommand.Refactor -> UserIntent.SUGGEST_ALTERNATE_IMPLEMENTATION
         EditorContextCommand.Fix -> UserIntent.APPLY_COMMON_BEST_PRACTICES
         EditorContextCommand.Optimize -> UserIntent.IMPROVE_CODE
-        EditorContextCommand.ExplainCodeScanIssue -> UserIntent.EXPLAIN_CODE_SELECTION
+        EditorContextCommand.HandleCodeScanIssue -> UserIntent.EXPLAIN_CODE_SELECTION
         EditorContextCommand.GenerateUnitTests -> UserIntent.GENERATE_UNIT_TESTS
         EditorContextCommand.SendToPrompt -> null
     }