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

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
@@ -72,6 +76,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
@@ -108,13 +114,23 @@
 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.CodeLine
+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.CodeWhispererCodeScanSession
+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(),
@@ -124,6 +140,7 @@
     val uiReady = CompletableDeferred<Boolean>()
     private val chatCommunicationManager = ChatCommunicationManager.getInstance(project)
     private val chatAsyncResultManager = ChatAsyncResultManager.getInstance(project)
+    private val codeScanManager = CodeWhispererCodeScanManager.getInstance(project)
 
     suspend fun connect(
         browser: Browser,
@@ -572,6 +589,33 @@
         }
     }
 
+    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,
@@ -585,10 +629,74 @@
                     throw error
                 }
                 chatCommunicationManager.removePartialChatMessage(partialResultToken)
+                val params = value?.let { encryptionManager?.decrypt(it) }.orEmpty()
+                val jsonObject = Gson().fromJson(params, Map::class.java)
+                val additionalMessages = jsonObject["additionalMessages"] as? MutableList<Map<String, Any>>
+                val findingsMessage = additionalMessages?.find {message ->
+                    (message["messageId"] as String).endsWith(CODE_REVIEW_FINDINGS_SUFFIX)
+                    || (message["messageId"] as String).endsWith(DISPLAY_FINDINGS_SUFFIX)}
+                val scannedFiles = mutableListOf<VirtualFile>();
+                if (findingsMessage != null) {
+                    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 = try {
+                            LocalFileSystem.getInstance().findFileByIoFile(
+                                Path.of(aggregatedIssue.filePath).toFile()
+                            )
+                        } catch (e: Exception) {
+                            null
+                        }
+                        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 = codeScanManager.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
+                                    ))
+                                }
+                            }
+                        }
+                    }
+
+                    codeScanManager.addOnDemandIssues(mappedFindings, scannedFiles, CodeWhispererConstants.CodeAnalysisScope.AGENTIC)
+                    codeScanManager.showCodeScanUI()
+                }
+
                 val messageToChat = ChatCommunicationManager.convertToJsonToSendToChat(
                     SEND_CHAT_COMMAND_PROMPT,
                     tabId,
-                    value?.let { encryptionManager?.decrypt(it) }.orEmpty(),
+                    Gson().toJson(jsonObject),
                     isPartialResult = false
                 )
                 browser.postChat(messageToChat)

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

@@ -18,33 +18,42 @@
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.SendToPromptParams
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.TriggerType
 
-class ExplainCodeIssueAction : AnAction(), DumbAware {
+class HandleIssueCommandAction : 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 startLineString = issueContext["startLine"]
+        val endLineString = issueContext["endLine"]
+        val startLineInteger = Integer.parseInt(startLineString)
+        val endLineInteger = Integer.parseInt(endLineString)
+        return if (startLineInteger == endLineInteger) {
+            "[${startLineInteger}]"
+        } else {
+            "[${startLineInteger}, ${endLineInteger}]"
+        }
+    }
 
     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 contextDataKey = DataKey.create<MutableMap<String, String>>("amazonq.codescan.handleIssueCommandContext")
+        val actionDataKey = DataKey.create<String>("amazonq.codescan.handleIssueCommandAction")
+        val context = e.getData(contextDataKey) ?: return
+        val action = e.getData(actionDataKey) ?: return
         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["issue"]}\" \n"
 
                 val params = SendToPromptParams(
                     selection = codeSelection,

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

@@ -108,8 +108,8 @@
 
         <group id = "aws.toolkit.explorer.codewhisperer.codescan">
             <action
-                id="aws.amazonq.explainCodeScanIssue"
-                class="software.aws.toolkits.jetbrains.services.cwc.commands.codescan.actions.ExplainCodeIssueAction"/>
+                id="aws.amazonq.handleCodeScanIssueCommand"
+                class="software.aws.toolkits.jetbrains.services.cwc.commands.codescan.actions.HandleIssueCommandAction"/>
             <action
                 id="aws.amazonq.codeScanComplete"
                 class="software.aws.toolkits.jetbrains.services.cwc.commands.codescan.actions.CodeScanCompleteAction" />

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanIssueDetailsPanel.kt

@@ -16,13 +16,13 @@
 import com.intellij.ui.components.JBScrollPane
 import com.intellij.util.Alarm
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.warn
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.context.CodeScanIssueDetailsDisplayType
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.additionBackgroundColor
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.additionForegroundColor
-import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.applySuggestedFix
+import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.applyFix
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.codeBlockBackgroundColor
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.codeBlockBorderColor
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.codeBlockForegroundColor
@@ -61,7 +61,7 @@
 internal class CodeWhispererCodeScanIssueDetailsPanel(
     private val project: Project,
     issue: CodeWhispererCodeScanIssue,
     private val defaultScope: CoroutineScope,
 ) : JPanel(BorderLayout()) {
     private val kit = HTMLEditorKit()
     private val doc = kit.createDefaultDocument()
@@ -143,9 +143,8 @@
 
             buttonPane.apply {
                 removeAll()
-                if (issue.suggestedFixes.isNotEmpty()) add(applyFixButton)
-                add(regenerateFixButton)
                 add(explainIssueButton)
+                add(applyFixButton)
                 add(ignoreIssueButton)
                 add(ignoreIssuesButton)
                 add(Box.createHorizontalGlue())
@@ -235,26 +234,8 @@
         font = font.deriveFont(16f)
     }
     private val applyFixButton = JButton(message("codewhisperer.codescan.apply_fix_button_label")).apply {
-        putClientProperty(DarculaButtonUI.DEFAULT_STYLE_KEY, true)
         addActionListener {
-            applySuggestedFix(project, issue)
-        }
-    }
-    private val generateFixButton = JButton(message("codewhisperer.codescan.generate_fix_button_label")).apply {
-        putClientProperty(DarculaButtonUI.DEFAULT_STYLE_KEY, true)
-        isEnabled = issue.ruleId != "sbom-software-assurance-services"
-        addActionListener {
-            defaultScope.launch {
-                handleGenerateFix(issue)
-            }
-        }
-    }
-    private val regenerateFixButton = JButton(message("codewhisperer.codescan.regenerate_fix_button_label")).apply {
-        putClientProperty(DarculaButtonUI.DEFAULT_STYLE_KEY, true)
-        addActionListener {
-            defaultScope.launch {
-                handleGenerateFix(issue, isRegenerate = true)
-            }
+            applyFix(issue)
         }
     }
     private val explainIssueButton = JButton(message("codewhisperer.codescan.explain_button_label")).apply {
@@ -298,9 +279,8 @@
     private val buttonPane = JPanel().apply {
         layout = BoxLayout(this, BoxLayout.X_AXIS)
         preferredSize = Dimension(this.width, 30)
-        if (issue.suggestedFixes.isNotEmpty()) add(applyFixButton)
-        if (issue.suggestedFixes.isNotEmpty()) add(regenerateFixButton) else add(generateFixButton)
         add(explainIssueButton)
+        add(applyFixButton)
         add(ignoreIssueButton)
         add(ignoreIssuesButton)
         add(Box.createHorizontalGlue())
@@ -333,10 +313,5 @@
         add(BorderLayout.SOUTH, buttonPane)
         isVisible = true
         revalidate()
-        if (issue.suggestedFixes.isEmpty()) {
-            defaultScope.launch {
-                handleGenerateFix(issue)
-            }
-        }
     }
 }

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanManager.kt

@@ -537,6 +537,15 @@ class CodeWhispererCodeScanManager(val project: Project) {
         ondemandScanIssues = ondemandScanIssues.filter { it.findingId != issue.findingId }
     }
 
+    fun addOnDemandIssues(issues: List<CodeWhispererCodeScanIssue>, scannedFiles: List<VirtualFile>, scope: CodeWhispererConstants.CodeAnalysisScope) = projectCoroutineScope(project).launch {
+        ondemandScanIssues = ondemandScanIssues + issues
+        renderResponseOnUIThread(
+            getCombinedScanIssues(),
+            scannedFiles,
+            scope
+        )
+    }
+
     fun removeIssueByFindingId(issue: CodeWhispererCodeScanIssue, findingId: String) {
         scanNodesLookup[issue.file]?.forEach { node ->
             val issueNode = node.userObject as CodeWhispererCodeScanIssue

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/listeners/CodeWhispererCodeScanEditorMouseMotionListener.kt

@@ -25,6 +25,7 @@ import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.CodeWhisp
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.context.CodeScanIssueDetailsDisplayType
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.additionBackgroundColor
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.additionForegroundColor
+import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.applyFix
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.applySuggestedFix
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.codeBlockBackgroundColor
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.codeBlockBorderColor
@@ -182,12 +183,21 @@ class CodeWhispererCodeScanEditorMouseMotionListener(private val project: Projec
         val explainButton = JButton(
             message("codewhisperer.codescan.explain_button_label")
         ).apply {
-            toolTipText = message("codewhisperer.codescan.apply_fix_button_tooltip")
+            toolTipText = message("codewhisperer.codescan.explain_button_tooltip")
             addActionListener {
                 hidePopup()
                 explainIssue(issue)
             }
         }
+        val applyFixButton = JButton(
+            message("codewhisperer.codescan.apply_fix_button_label")
+        ).apply {
+            toolTipText = message("codewhisperer.codescan.apply_fix_button_tooltip")
+            addActionListener {
+                hidePopup()
+                applyFix(issue)
+            }
+        }
 
         val titlePane = JPanel().apply {
             layout = BoxLayout(this, BoxLayout.X_AXIS)
@@ -204,6 +214,7 @@ class CodeWhispererCodeScanEditorMouseMotionListener(private val project: Projec
                 add(button)
             }
             add(explainButton)
+            add(applyFixButton)
 
             // Add glue before and after label to center it
             add(Box.createHorizontalGlue())

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/sessionconfig/CodeScanSessionConfig.kt

@@ -107,6 +107,7 @@ class CodeScanSessionConfig(
                 null -> getProjectPayloadMetadata()
                 else -> when (scope) {
                     CodeAnalysisScope.PROJECT -> getProjectPayloadMetadata()
+                    CodeAnalysisScope.AGENTIC -> getProjectPayloadMetadata()
                     CodeAnalysisScope.FILE -> if (selectedFile.isWithin(projectRoot)) {
                         getFilePayloadMetadata(selectedFile, true)
                     } else {