Merge main into feature/q-dev-ux

Author: aws-toolkit-automation

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/editor/context/project/EncoderServer.kt

@@ -51,7 +51,7 @@ class EncoderServer(val project: Project) : Disposable {
     val port by lazy { NetUtils.findAvailableSocketPort() }
     private val nodeRunnableName = if (manifestManager.getOs() == "windows") "node.exe" else "node"
     private val maxRetry: Int = 3
-    val key = generateHmacKey()
+    private val key = generateHmacKey()
     private var processHandler: KillableProcessHandler? = null
     private val mapper = jacksonObjectMapper()
 

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/editor/context/project/ProjectContextController.kt

@@ -8,19 +8,18 @@ import com.intellij.openapi.components.Service
 import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
+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.core.coroutines.disposableCoroutineScope
 import software.aws.toolkits.jetbrains.services.codewhisperer.settings.CodeWhispererSettings
 
 @Service(Service.Level.PROJECT)
-class ProjectContextController(private val project: Project) : Disposable {
+class ProjectContextController(private val project: Project, private val cs: CoroutineScope) : Disposable {
     private val encoderServer: EncoderServer = EncoderServer(project)
-    private val projectContextProvider: ProjectContextProvider = ProjectContextProvider(project, encoderServer)
-    private val scope = disposableCoroutineScope(this)
+    private val projectContextProvider: ProjectContextProvider = ProjectContextProvider(project, encoderServer, cs)
     init {
-        scope.launch {
+        cs.launch {
             if (CodeWhispererSettings.getInstance().isProjectContextEnabled()) {
                 encoderServer.downloadArtifactsAndStartServer()
             }

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/editor/context/project/ProjectContextProvider.kt

@@ -14,6 +14,7 @@ import com.intellij.openapi.vfs.VfsUtilCore
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.VirtualFileVisitor
 import com.intellij.openapi.vfs.isFile
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
@@ -22,7 +23,6 @@ import software.aws.toolkits.core.utils.debug
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.info
 import software.aws.toolkits.core.utils.warn
-import software.aws.toolkits.jetbrains.core.coroutines.disposableCoroutineScope
 import software.aws.toolkits.jetbrains.services.amazonq.FeatureDevSessionContext
 import software.aws.toolkits.jetbrains.services.codewhisperer.settings.CodeWhispererSettings
 import software.aws.toolkits.jetbrains.services.cwc.controller.chat.telemetry.TelemetryHelper
@@ -33,13 +33,12 @@ import java.net.URL
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicInteger
 
-class ProjectContextProvider(val project: Project, private val encoderServer: EncoderServer) : Disposable {
+class ProjectContextProvider(val project: Project, private val encoderServer: EncoderServer, private val cs: CoroutineScope) : Disposable {
     private val retryCount = AtomicInteger(0)
     val isIndexComplete = AtomicBoolean(false)
     private val mapper = jacksonObjectMapper()
-    private val scope = disposableCoroutineScope(this)
     init {
-        scope.launch {
+        cs.launch {
             if (CodeWhispererSettings.getInstance().isProjectContextEnabled()) {
                 while (true) {
                     if (encoderServer.isNodeProcessRunning()) {
@@ -106,7 +105,7 @@ class ProjectContextProvider(val project: Project, private val encoderServer: En
     )
 
     private fun initAndIndex() {
-        scope.launch {
+        cs.launch {
             while (retryCount.get() < 5) {
                 try {
                     logger.info { "project context: about to init key" }
@@ -283,7 +282,7 @@ class ProjectContextProvider(val project: Project, private val encoderServer: En
                     // TODO: refactor this along with /dev & codescan file traversing logic
                     override fun visitFile(file: VirtualFile): Boolean {
                         if ((file.isDirectory && isBuildOrBin(file.name)) ||
-                            runBlocking { featureDevSessionContext.ignoreFile(file.name, scope) } ||
+                            runBlocking { featureDevSessionContext.ignoreFile(file.name) } ||
                             (file.isFile && file.length > 10 * 1024 * 1024)
                         ) {
                             return false

plugins/amazonq/chat/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/workspace/context/EncoderServerTest.kt

@@ -21,7 +21,7 @@ class EncoderServerTest {
     private val inputBytes = BigInteger(32, DigestUtil.random).toByteArray()
 
     @Before
-    open fun setup() {
+    fun setup() {
         encoderServer = EncoderServer(projectRule.project)
     }
 

plugins/amazonq/chat/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/workspace/context/ProjectContextProviderTest.kt

@@ -4,6 +4,8 @@
 package software.aws.toolkits.jetbrains.services.amazonq.workspace.context
 
 import com.intellij.openapi.project.Project
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Rule
 import org.mockito.kotlin.any
@@ -22,18 +24,20 @@ class ProjectContextProviderTest {
     @Rule
     @JvmField
     val projectRule: CodeInsightTestFixtureRule = JavaCodeInsightTestFixtureRule()
-    internal lateinit var project: Project
+
+    private val project: Project
+        get() = projectRule.project
+
     private val encoderServer: EncoderServer = mock()
     private lateinit var sut: ProjectContextProvider
 
     @Before
-    open fun setup() {
-        project = projectRule.project
-        sut = ProjectContextProvider(project, encoderServer)
+    fun setup() {
+        sut = ProjectContextProvider(project, encoderServer, TestScope())
     }
 
     @Test
-    fun `test index payload is encrypted`() {
+    fun `test index payload is encrypted`() = runTest {
         whenever(encoderServer.port).thenReturn(3000)
         try {
             sut.index()
@@ -43,7 +47,8 @@ class ProjectContextProviderTest {
         verify(encoderServer, times(1)).encrypt(any())
     }
 
-    fun `test query payload is encrypted`() {
+    @Test
+    fun `test query payload is encrypted`() = runTest {
         whenever(encoderServer.port).thenReturn(3000)
         try {
             sut.query("what does this project do")

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

@@ -186,7 +186,7 @@ class CodeScanSessionConfig(
 
                     if (!current.isDirectory) {
                         if (current.isFile && !changeListManager.isIgnoredFile(current) &&
-                            runBlocking { !featureDevSessionContext.ignoreFile(current, this) } &&
+                            runBlocking { !featureDevSessionContext.ignoreFile(current) } &&
                             runReadAction { !fileIndex.isInLibrarySource(current) }
                         ) {
                             if (willExceedPayloadLimit(currentTotalFileSize, current.length)) {
@@ -209,7 +209,7 @@ class CodeScanSessionConfig(
                     } else {
                         // Directory case: only traverse if not ignored
                         if (!changeListManager.isIgnoredFile(current) &&
-                            runBlocking { !featureDevSessionContext.ignoreFile(current, this) } &&
+                            runBlocking { !featureDevSessionContext.ignoreFile(current) } &&
                             !traversedDirectories.contains(current) && current.isValid &&
                             runReadAction { !fileIndex.isInLibrarySource(current) }
                         ) {

plugins/core/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/FeatureDevSessionContext.kt

@@ -10,7 +10,6 @@ import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.VirtualFileVisitor
 import com.intellij.openapi.vfs.isFile
 import com.intellij.platform.ide.progress.withBackgroundProgress
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.async
 import kotlinx.coroutines.flow.channelFlow
 import kotlinx.coroutines.launch
@@ -29,6 +28,7 @@ import java.nio.file.Files
 import java.nio.file.Path
 import java.util.Base64
 import java.util.zip.ZipOutputStream
+import kotlin.coroutines.coroutineContext
 import kotlin.io.path.Path
 import kotlin.io.path.relativeTo
 
@@ -97,19 +97,23 @@ class FeatureDevSessionContext(val project: Project, val maxProjectSizeBytes: Lo
         return FeatureDevBundleConfig.ALLOWED_CODE_EXTENSIONS.contains(extension)
     }
 
-    private fun ignoreFileByExtension(file: VirtualFile, scope: CoroutineScope): Boolean = with(scope) {
-        return !isFileExtensionAllowed(file)
-    }
+    private fun ignoreFileByExtension(file: VirtualFile) =
+        !isFileExtensionAllowed(file)
 
-    suspend fun ignoreFile(file: VirtualFile, scope: CoroutineScope): Boolean = ignoreFile(file.path, scope)
+    suspend fun ignoreFile(file: VirtualFile): Boolean = ignoreFile(file.path)
 
-    suspend fun ignoreFile(path: String, scope: CoroutineScope): Boolean = with(scope) {
+    suspend fun ignoreFile(path: String): Boolean {
+        // this method reads like something a JS dev would write and doesn't do what the author thinks
         val deferredResults = ignorePatternsWithGitIgnore.map { pattern ->
-            async {
-                pattern.containsMatchIn(path)
+            withContext(coroutineContext) {
+                async { pattern.containsMatchIn(path) }
             }
         }
-        deferredResults.any { it.await() }
+
+        // this will serially iterate over and block
+        // ideally we race the results https://github.com/Kotlin/kotlinx.coroutines/issues/2867
+        // i.e. Promise.any(...)
+        return deferredResults.any { it.await() }
     }
 
     suspend fun zipFiles(projectRoot: VirtualFile): File = withContext(getCoroutineBgContext()) {
@@ -121,13 +125,13 @@ class FeatureDevSessionContext(val project: Project, val maxProjectSizeBytes: Lo
             projectRoot,
             object : VirtualFileVisitor<Unit>() {
                 override fun visitFile(file: VirtualFile): Boolean {
-                    val isFileIgnoredByExtension = runBlocking { ignoreFileByExtension(file, this) }
+                    val isFileIgnoredByExtension = runBlocking { ignoreFileByExtension(file) }
                     if (isFileIgnoredByExtension) {
                         val extension = file.extension.orEmpty()
                         ignoredExtensionMap[extension] = (ignoredExtensionMap[extension] ?: 0) + 1
                         return false
                     }
-                    val isFileIgnoredByPattern = runBlocking { ignoreFile(file.name, this) }
+                    val isFileIgnoredByPattern = runBlocking { ignoreFile(file.name) }
                     if (isFileIgnoredByPattern) {
                         return false
                     }