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

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

@@ -325,7 +325,7 @@
             [email protected] {
                 DefaultAuthCredentialsService(project, encryptionManager, this)
                 TextDocumentServiceHandler(project, this)
-                WorkspaceServiceHandler(project, this)
+                WorkspaceServiceHandler(project, initializeResult.getCompleted(), this)
                 DefaultModuleDependenciesService(project, this)
             }
         }

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

@@ -22,7 +22,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.WorkspaceFolder
 import org.eclipse.lsp4j.WorkspaceFoldersChangeEvent
@@ -31,20 +33,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
@@ -56,10 +60,44 @@
         )
     }
 
+    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 ->
-                val file = event.file?.takeIf { shouldHandleFile(it) } ?: return@mapNotNull null
+                val file = event.file?.takeIf { shouldHandleFile(it, FileOperationType.CREATE) } ?: return@mapNotNull null
                 toUriString(file)?.let { uri ->
                     FileCreate().apply {
                         this.uri = uri
@@ -80,7 +118,7 @@
     private fun didDeleteFiles(events: List<VFileEvent>) {
         AmazonQLspService.executeIfRunning(project) { languageServer ->
             val validFiles = events.mapNotNull { event ->
-                val file = event.file?.takeIf { shouldHandleFile(it) } ?: return@mapNotNull null
+                val file = event.file?.takeIf { shouldHandleFile(it, FileOperationType.DELETE) } ?: return@mapNotNull null
                 toUriString(file)?.let { uri ->
                     FileDelete().apply {
                         this.uri = uri
@@ -103,7 +141,7 @@
             val validRenames = events
                 .filter { it.propertyName == VirtualFile.PROP_NAME }
                 .mapNotNull { event ->
-                    val file = event.file.takeIf { shouldHandleFile(it) } ?: return@mapNotNull null
+                    val file = event.file.takeIf { shouldHandleFile(it, FileOperationType.RENAME) } ?: return@mapNotNull null
                     if (event.newValue !is String) return@mapNotNull null
 
                     // Construct old and new URIs
@@ -186,13 +224,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

@@ -29,8 +29,15 @@ import org.eclipse.lsp4j.DeleteFilesParams
 import org.eclipse.lsp4j.DidChangeWatchedFilesParams
 import org.eclipse.lsp4j.DidChangeWorkspaceFoldersParams
 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.WorkspaceService
 import org.junit.jupiter.api.Assertions.assertEquals
@@ -46,10 +53,11 @@ 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 sut: WorkspaceServiceHandler
-    private lateinit var mockApplication: Application
 
     @BeforeEach
     fun setup() {
@@ -94,7 +102,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