feat(amazonq): skip registering run command log file

Author: karanA-aws

.changes/next-release/feature-5391ea41-f418-4154-9f0c-5de8bacf1aeb.json

@@ -0,0 +1,4 @@
+{
+  "type" : "feature",
+  "description" : "The logs emitted by the Agent during user command execution will be accepted and written to `.amazonq/dev/run_command.log` file in the user's local repository."
+}

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonqFeatureDev/session/CodeGenerationState.kt

@@ -3,6 +3,7 @@
 
 package software.aws.toolkits.jetbrains.services.amazonqFeatureDev.session
 
+import com.intellij.openapi.vfs.VirtualFile
 import kotlinx.coroutines.delay
 import software.amazon.awssdk.services.codewhispererruntime.model.CodeGenerationWorkflowStatus
 import software.aws.toolkits.core.utils.getLogger
@@ -27,8 +28,13 @@ import software.aws.toolkits.jetbrains.services.cwc.controller.chat.telemetry.ge
 import software.aws.toolkits.resources.message
 import software.aws.toolkits.telemetry.AmazonqTelemetry
 import software.aws.toolkits.telemetry.MetricResult
+import java.nio.charset.StandardCharsets
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
 import java.util.UUID
 
+fun VirtualFile.toNioPath(): Path = Paths.get(this.path)
 private val logger = getLogger<CodeGenerationState>()
 
 class CodeGenerationState(
@@ -181,6 +187,18 @@ class CodeGenerationState(
     }
 }
 
+private fun writeLogFile(addressableRoot: Any?, fileRelativePath: String, contents: String) {
+    val addressablePath = when (addressableRoot) {
+        is VirtualFile -> addressableRoot.toNioPath()
+        is Path -> addressableRoot
+        else -> Paths.get(System.getProperty("java.io.tmpdir"))
+    }
+    val filePath = addressablePath.resolve(fileRelativePath)
+
+    Files.createDirectories(filePath.parent)
+    Files.write(filePath, contents.toByteArray(StandardCharsets.UTF_8))
+}
+
 private suspend fun CodeGenerationState.generateCode(
     codeGenerationId: String,
     messenger: MessagePublisher,
@@ -211,6 +229,13 @@ private suspend fun CodeGenerationState.generateCode(
                         conversationId = config.conversationId,
                     )
 
+                for (file in codeGenerationStreamResult.new_file_contents.keys) {
+                    if (file.endsWith(".amazonq/dev/run_command.log")) {
+                        val contents = codeGenerationStreamResult.new_file_contents[file].orEmpty()
+                        writeLogFile(config.repoContext.addressableRoot, file, contents)
+                    }
+                }
+
                 val newFileInfo = registerNewFiles(newFileContents = codeGenerationStreamResult.new_file_contents)
                 val deletedFileInfo = registerDeletedFiles(deletedFiles = codeGenerationStreamResult.deleted_files)
 
@@ -267,14 +292,18 @@ private suspend fun CodeGenerationState.generateCode(
 }
 
 fun registerNewFiles(newFileContents: Map<String, String>): List<NewFileZipInfo> =
-    newFileContents.map {
-        NewFileZipInfo(
-            // Note: When managing file state, we normalize file paths returned from the agent in order to ensure they are handled as relative paths.
-            zipFilePath = it.key.removePrefix("/"),
-            fileContent = it.value,
-            rejected = false,
-            changeApplied = false
-        )
+    newFileContents.mapNotNull { (key, value) ->
+        if (key.endsWith(".amazonq/dev/run_command.log")) {
+            null
+        } else {
+            NewFileZipInfo(
+                // Note: When managing file state, we normalize file paths returned from the agent in order to ensure they are handled as relative paths.
+                zipFilePath = key.removePrefix("/"),
+                fileContent = value,
+                rejected = false,
+                changeApplied = false
+            )
+        }
     }
 
 fun registerDeletedFiles(deletedFiles: List<String>): List<DeletedFileInfo> =

plugins/amazonq/chat/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonqFeatureDev/FeatureDevTestBase.kt

@@ -65,6 +65,8 @@ open class FeatureDevTestBase(
     internal val otherStatus = "Other"
     internal val testTabId = "test-tab-id"
     internal val testFilePaths = mapOf(Pair("test.ts", "This is a comment"))
+    internal val testRunCommandLogPath = ".amazonq/dev/run_command.log"
+    internal val testLogPath = mapOf(Pair(testRunCommandLogPath, "This is a log"))
     internal val testDeletedFiles = listOf("deleted.ts")
     internal val testReferences = listOf(CodeReferenceGenerated())
     internal val testChecksumSha = "test-sha"

plugins/amazonq/chat/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonqFeatureDev/session/CodeGenerationStateTest.kt

@@ -3,6 +3,7 @@
 
 package software.aws.toolkits.jetbrains.services.amazonqFeatureDev.session
 
+import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.testFramework.RuleChain
 import io.mockk.coEvery
 import io.mockk.coVerify
@@ -11,6 +12,7 @@ import io.mockk.just
 import io.mockk.mockk
 import io.mockk.mockkStatic
 import io.mockk.runs
+import io.mockk.slot
 import io.mockk.unmockkAll
 import io.mockk.verify
 import kotlinx.coroutines.test.runTest
@@ -29,6 +31,8 @@ import software.aws.toolkits.jetbrains.services.amazonqFeatureDev.messages.sendA
 import software.aws.toolkits.jetbrains.services.amazonqFeatureDev.util.FeatureDevService
 import software.aws.toolkits.jetbrains.services.cwc.messages.CodeReference
 import software.aws.toolkits.resources.message
+import java.nio.file.Files
+import java.nio.file.Paths
 
 class CodeGenerationStateTest : FeatureDevTestBase() {
     @Rule
@@ -39,13 +43,14 @@ class CodeGenerationStateTest : FeatureDevTestBase() {
     private lateinit var messenger: MessagePublisher
     private val action = SessionStateAction("test-task", userMessage)
     private lateinit var featureDevService: FeatureDevService
+    private lateinit var repoContext: FeatureDevSessionContext
 
     @Before
     override fun setup() {
         featureDevService = mockk<FeatureDevService>()
         every { featureDevService.project } returns projectRule.project
         messenger = mock()
-        val repoContext = mock<FeatureDevSessionContext>()
+        repoContext = mockk<FeatureDevSessionContext>()
         val sessionStateConfig = SessionStateConfig(testConversationId, repoContext, featureDevService)
 
         codeGenerationState =
@@ -103,6 +108,66 @@ class CodeGenerationStateTest : FeatureDevTestBase() {
         coVerify(exactly = 1) { featureDevService.exportTaskAssistArchiveResult(testConversationId) }
     }
 
+    @Test
+    fun `test code generated is complete with run_command log contents verification`() {
+        val action = SessionStateAction("test-task", userMessage)
+
+        val tempDir = Files.createTempDirectory("testRepo")
+        val mockedFile = mockk<VirtualFile>()
+        every { mockedFile.exists() } returns true
+        every { mockedFile.isDirectory } returns true
+        every { mockedFile.path } returns tempDir.toAbsolutePath().toString()
+        every { mockedFile.toNioPath() } returns tempDir
+
+        val pathSlot = slot<String>()
+        every { mockedFile.findFileByRelativePath(capture(pathSlot)) } answers {
+            val path = pathSlot.captured
+            val filePath = tempDir.resolve(path)
+            if (!Files.exists(filePath)) {
+                Files.createFile(filePath)
+            }
+            val file = mockk<VirtualFile>()
+            every { file.exists() } returns true
+            every { file.isDirectory } returns Files.isDirectory(filePath)
+            every { file.path } returns filePath.toAbsolutePath().toString()
+            file
+        }
+
+        every { repoContext.addressableRoot } returns mockedFile
+
+        every { featureDevService.getTaskAssistCodeGeneration(any(), any()) } returns exampleCompleteGetTaskAssistCodeGenerationResponse
+        every { featureDevService.startTaskAssistCodeGeneration(any(), any(), any(), any(), any()) } returns exampleStartTaskAssistConversationResponse
+        coEvery { featureDevService.exportTaskAssistArchiveResult(any()) } returns
+            CodeGenerationStreamResult(testLogPath, testDeletedFiles, testReferences)
+
+        runTest {
+            val actual = codeGenerationState.interact(action)
+            assertThat(actual.nextState).isInstanceOf(PrepareCodeGenerationState::class.java)
+            val nextState = actual.nextState as PrepareCodeGenerationState
+            assertThat(nextState.phase).isEqualTo(SessionStatePhase.CODEGEN)
+            assertThat(nextState.filePaths).doesNotContain(
+                NewFileZipInfo(testRunCommandLogPath, "This is a log", rejected = false, changeApplied = false)
+            )
+            assertThat(nextState.filePaths.size).isEqualTo(0)
+            assertThat(nextState.deletedFiles).isEqualTo(
+                listOf(DeletedFileInfo("deleted.ts", rejected = false, changeApplied = false))
+            )
+            assertThat(nextState.references).isEqualTo(testReferences)
+            assertThat(nextState.codeGenerationRemainingIterationCount).isEqualTo(2)
+            assertThat(nextState.codeGenerationTotalIterationCount).isEqualTo(3)
+            assertThat(actual.interaction.interactionSucceeded).isEqualTo(true)
+            assertThat(actual.interaction.content).isEqualTo("")
+            assertThat(mockedFile.findFileByRelativePath(testRunCommandLogPath)).isNotNull
+            val file = requireNotNull(mockedFile.findFileByRelativePath(testRunCommandLogPath)) { "File not found" }
+            assertThat(Files.readString(Paths.get(file.path))).isEqualTo("This is a log")
+        }
+
+        assertThat(codeGenerationState.phase).isEqualTo(SessionStatePhase.CODEGEN)
+        coVerify(exactly = 1) { messenger.sendAnswerPart(testTabId, message("amazonqFeatureDev.code_generation.generating_code")) }
+        verify(exactly = 1) { featureDevService.getTaskAssistCodeGeneration(testConversationId, codeGenerationId) }
+        coVerify(exactly = 1) { featureDevService.exportTaskAssistArchiveResult(testConversationId) }
+    }
+
     @Test(expected = FeatureDevException::class)
     fun `test code generation failed`() =
         runTest {