feat(amazonq): fetch filePatterns from initializeResponse for workspace messages

plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/AmazonQLspService.kt

@@ -317,15 +317,15 @@
         }
 
         // invokeOnCompletion results in weird lock/timeout error
-        initializeResult.asCompletableFuture().handleAsync { r, ex ->
+        initializeResult.asCompletableFuture().handleAsync { lspInitResult, ex ->
             if (ex != null) {
                 return@handleAsync
             }
 
             [email protected] {
                 DefaultAuthCredentialsService(project, encryptionManager, this)
                 TextDocumentServiceHandler(project, this)
-                WorkspaceServiceHandler(project, this)
+                WorkspaceServiceHandler(project, lspInitResult, this)
                 DefaultModuleDependenciesService(project, this)
             }
         }

plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/workspace/WorkspaceServiceHandler.kt

@@ -26,7 +26,9 @@
 import org.eclipse.lsp4j.FileCreate
 import org.eclipse.lsp4j.FileDelete
 import org.eclipse.lsp4j.FileEvent
+import org.eclipse.lsp4j.FileOperationFilter
 import org.eclipse.lsp4j.FileRename
+import org.eclipse.lsp4j.InitializeResult
 import org.eclipse.lsp4j.RenameFilesParams
 import org.eclipse.lsp4j.TextDocumentIdentifier
 import org.eclipse.lsp4j.TextDocumentItem
@@ -37,20 +39,22 @@
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.util.WorkspaceFolderUtil.createWorkspaceFolders
 import software.aws.toolkits.jetbrains.utils.pluginAwareExecuteOnPooledThread
 import java.nio.file.FileSystems
+import java.nio.file.PathMatcher
 import java.nio.file.Paths
 
 class WorkspaceServiceHandler(
     private val project: Project,
+    initializeResult: InitializeResult,
     serverInstance: Disposable,
 ) : BulkFileListener,
     ModuleRootListener {
 
     private var lastSnapshot: List<WorkspaceFolder> = emptyList()
-    private val supportedFilePatterns = FileSystems.getDefault().getPathMatcher(
-        "glob:**/*.{ts,js,py,java}"
-    )
+    private val operationMatchers: MutableMap<FileOperationType, List<Pair<PathMatcher, String>>> = mutableMapOf()
 
     init {
+        operationMatchers.putAll(initializePatterns(initializeResult))
+
         project.messageBus.connect(serverInstance).subscribe(
             VirtualFileManager.VFS_CHANGES,
             this
@@ -62,12 +66,46 @@
         )
     }
 
+    enum class FileOperationType {
+        CREATE,
+        DELETE,
+        RENAME,
+    }
+
+    private fun initializePatterns(initializeResult: InitializeResult): Map<FileOperationType, List<Pair<PathMatcher, String>>> {
+        val patterns = mutableMapOf<FileOperationType, List<Pair<PathMatcher, String>>>()
+
+        initializeResult.capabilities?.workspace?.fileOperations?.let { fileOps ->
+            patterns[FileOperationType.CREATE] = createMatchers(fileOps.didCreate?.filters)
+            patterns[FileOperationType.DELETE] = createMatchers(fileOps.didDelete?.filters)
+            patterns[FileOperationType.RENAME] = createMatchers(fileOps.didRename?.filters)
+        }
+
+        return patterns
+    }
+
+    private fun createMatchers(filters: List<FileOperationFilter>?): List<Pair<PathMatcher, String>> =
+        filters?.map { filter ->
+            FileSystems.getDefault().getPathMatcher("glob:${filter.pattern.glob}") to filter.pattern.matches
+        }.orEmpty()
+
+    private fun shouldHandleFile(file: VirtualFile, operation: FileOperationType): Boolean {
+        val matchers = operationMatchers[operation] ?: return false
+        return matchers.any { (matcher, type) ->
+            when (type) {
+                "file" -> !file.isDirectory && matcher.matches(Paths.get(file.path))
+                "folder" -> file.isDirectory && matcher.matches(Paths.get(file.path))
+                else -> matcher.matches(Paths.get(file.path))
+            }
+        }
+    }
+
     private fun didCreateFiles(events: List<VFileEvent>) {
         AmazonQLspService.executeIfRunning(project) { languageServer ->
             val validFiles = events.mapNotNull { event ->
                 when (event) {
                     is VFileCopyEvent -> {
-                        val newFile = event.newParent.findChild(event.newChildName)?.takeIf { shouldHandleFile(it) }
+                        val newFile = event.newParent.findChild(event.newChildName)?.takeIf { shouldHandleFile(it, FileOperationType.CREATE) }
                             ?: return@mapNotNull null
                         toUriString(newFile)?.let { uri ->
                             FileCreate().apply {
@@ -76,7 +114,7 @@
                         }
                     }
                     else -> {
-                        val file = event.file?.takeIf { shouldHandleFile(it) }
+                        val file = event.file?.takeIf { shouldHandleFile(it, FileOperationType.CREATE) }
                             ?: return@mapNotNull null
                         toUriString(file)?.let { uri ->
                             FileCreate().apply {
@@ -102,11 +140,11 @@
             val validFiles = events.mapNotNull { event ->
                 when (event) {
                     is VFileDeleteEvent -> {
-                        val file = event.file.takeIf { shouldHandleFile(it) } ?: return@mapNotNull null
+                        val file = event.file.takeIf { shouldHandleFile(it, FileOperationType.DELETE) } ?: return@mapNotNull null
                         toUriString(file)
                     }
                     is VFileMoveEvent -> {
-                        val oldFile = event.oldParent?.takeIf { shouldHandleFile(it) } ?: return@mapNotNull null
+                        val oldFile = event.oldParent?.takeIf { shouldHandleFile(it, FileOperationType.DELETE) } ?: return@mapNotNull null
                         toUriString(oldFile)
                     }
                     else -> null
@@ -132,7 +170,7 @@
             val validRenames = events
                 .filter { it.propertyName == VirtualFile.PROP_NAME }
                 .mapNotNull { event ->
-                    val renamedFile = event.file.takeIf { shouldHandleFile(it) } ?: return@mapNotNull null
+                    val renamedFile = event.file.takeIf { shouldHandleFile(it, FileOperationType.RENAME) } ?: return@mapNotNull null
                     val oldFileName = event.oldValue as? String ?: return@mapNotNull null
                     val parentFile = renamedFile.parent ?: return@mapNotNull null
 
@@ -275,13 +313,4 @@
             lastSnapshot = currentSnapshot
         }
     }
-
-    private fun shouldHandleFile(file: VirtualFile): Boolean {
-        if (file.isDirectory) {
-            return true // Matches "**/*" with matches: "folder"
-        }
-        val path = Paths.get(file.path)
-        val result = supportedFilePatterns.matches(path)
-        return result
-    }
 }

plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/workspace/WorkspaceServiceHandlerTest.kt

@@ -35,8 +35,15 @@ import org.eclipse.lsp4j.DidChangeWorkspaceFoldersParams
 import org.eclipse.lsp4j.DidCloseTextDocumentParams
 import org.eclipse.lsp4j.DidOpenTextDocumentParams
 import org.eclipse.lsp4j.FileChangeType
+import org.eclipse.lsp4j.FileOperationFilter
+import org.eclipse.lsp4j.FileOperationOptions
+import org.eclipse.lsp4j.FileOperationPattern
+import org.eclipse.lsp4j.FileOperationsServerCapabilities
+import org.eclipse.lsp4j.InitializeResult
 import org.eclipse.lsp4j.RenameFilesParams
+import org.eclipse.lsp4j.ServerCapabilities
 import org.eclipse.lsp4j.WorkspaceFolder
+import org.eclipse.lsp4j.WorkspaceServerCapabilities
 import org.eclipse.lsp4j.jsonrpc.messages.ResponseMessage
 import org.eclipse.lsp4j.services.TextDocumentService
 import org.eclipse.lsp4j.services.WorkspaceService
@@ -52,11 +59,12 @@ import java.util.concurrent.CompletableFuture
 
 class WorkspaceServiceHandlerTest {
     private lateinit var project: Project
+    private lateinit var mockApplication: Application
+    private lateinit var mockInitializeResult: InitializeResult
     private lateinit var mockLanguageServer: AmazonQLanguageServer
     private lateinit var mockWorkspaceService: WorkspaceService
     private lateinit var mockTextDocumentService: TextDocumentService
     private lateinit var sut: WorkspaceServiceHandler
-    private lateinit var mockApplication: Application
 
     @BeforeEach
     fun setup() {
@@ -107,7 +115,38 @@ class WorkspaceServiceHandlerTest {
         every { messageBus.connect(any<Disposable>()) } returns mockConnection
         every { mockConnection.subscribe(any(), any()) } just runs
 
-        sut = WorkspaceServiceHandler(project, mockk())
+        // Mock InitializeResult with file operation patterns
+        mockInitializeResult = mockk<InitializeResult>()
+        val mockCapabilities = mockk<ServerCapabilities>()
+        val mockWorkspaceCapabilities = mockk<WorkspaceServerCapabilities>()
+        val mockFileOperations = mockk<FileOperationsServerCapabilities>()
+
+        val fileFilter = FileOperationFilter().apply {
+            pattern = FileOperationPattern().apply {
+                glob = "**/*.{ts,js,py,java}"
+                matches = "file"
+            }
+        }
+        val folderFilter = FileOperationFilter().apply {
+            pattern = FileOperationPattern().apply {
+                glob = "**/*"
+                matches = "folder"
+            }
+        }
+
+        val fileOperationOptions = FileOperationOptions().apply {
+            filters = listOf(fileFilter, folderFilter)
+        }
+
+        every { mockFileOperations.didCreate } returns fileOperationOptions
+        every { mockFileOperations.didDelete } returns fileOperationOptions
+        every { mockFileOperations.didRename } returns fileOperationOptions
+        every { mockWorkspaceCapabilities.fileOperations } returns mockFileOperations
+        every { mockCapabilities.workspace } returns mockWorkspaceCapabilities
+        every { mockInitializeResult.capabilities } returns mockCapabilities
+
+        // Create WorkspaceServiceHandler with mocked InitializeResult
+        sut = WorkspaceServiceHandler(project, mockInitializeResult, mockk())
     }
 
     @Test