get SupportedFiletype globs from initializeResult

Author: samgst-amazon

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

@@ -309,7 +309,7 @@ private class AmazonQServerInstance(private val project: Project, private val cs
 
         DefaultAuthCredentialsService(project, encryptionManager, this)
         TextDocumentServiceHandler(project, this)
-        WorkspaceServiceHandler(project, this)
+        WorkspaceServiceHandler(project, initializeResult, this)
     }
 
     override fun dispose() {

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

@@ -14,6 +14,7 @@ import com.intellij.openapi.vfs.newvfs.events.VFileCreateEvent
 import com.intellij.openapi.vfs.newvfs.events.VFileDeleteEvent
 import com.intellij.openapi.vfs.newvfs.events.VFileEvent
 import com.intellij.openapi.vfs.newvfs.events.VFilePropertyChangeEvent
+import kotlinx.coroutines.Deferred
 import org.eclipse.lsp4j.CreateFilesParams
 import org.eclipse.lsp4j.DeleteFilesParams
 import org.eclipse.lsp4j.DidChangeWatchedFilesParams
@@ -22,28 +23,34 @@ import org.eclipse.lsp4j.FileChangeType
 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
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.AmazonQLspService
 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,
+    private val initializeResult: Deferred<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 {
+        initializeResult.invokeOnCompletion {
+            operationMatchers.putAll(initializePatterns(initializeResult.getCompleted()))
+        }
+
         project.messageBus.connect(serverInstance).subscribe(
             VirtualFileManager.VFS_CHANGES,
             this
@@ -55,10 +62,44 @@ class WorkspaceServiceHandler(
         )
     }
 
+    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
+        } ?: emptyList()
+
+    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
                 file.toNioPath().toUri().toString().takeIf { it.isNotEmpty() }?.let { uri ->
                     FileCreate().apply {
                         this.uri = uri
@@ -79,7 +120,7 @@ class WorkspaceServiceHandler(
     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
                 file.toNioPath().toUri().toString().takeIf { it.isNotEmpty() }?.let { uri ->
                     FileDelete().apply {
                         this.uri = uri
@@ -102,7 +143,7 @@ class WorkspaceServiceHandler(
             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
                     val oldName = event.oldValue as? String ?: return@mapNotNull null
                     if (event.newValue !is String) return@mapNotNull null
 
@@ -186,13 +227,4 @@ class WorkspaceServiceHandler(
             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

@@ -23,14 +23,22 @@ import io.mockk.mockkStatic
 import io.mockk.runs
 import io.mockk.slot
 import io.mockk.verify
+import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.test.runTest
 import org.eclipse.lsp4j.CreateFilesParams
 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
@@ -94,7 +102,40 @@ 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
+        val 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
+
+        val mockDeferred = CompletableDeferred(mockInitializeResult)
+
+        // Create WorkspaceServiceHandler with mocked InitializeResult
+        sut = WorkspaceServiceHandler(project, mockDeferred, mockk())
     }
 
     @Test