feat(amazonq): implement workspace file messages

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

@@ -37,7 +37,6 @@
 import org.eclipse.lsp4j.SynchronizationCapabilities
 import org.eclipse.lsp4j.TextDocumentClientCapabilities
 import org.eclipse.lsp4j.WorkspaceClientCapabilities
-import org.eclipse.lsp4j.WorkspaceFolder
 import org.eclipse.lsp4j.jsonrpc.Launcher
 import org.eclipse.lsp4j.launch.LSPLauncher
 import org.slf4j.event.Level
@@ -48,14 +47,15 @@
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.auth.DefaultAuthCredentialsService
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.encryption.JwtEncryptionManager
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.createExtendedClientMetadata
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.util.WorkspaceFolderUtil.createWorkspaceFolders
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.workspace.WorkspaceServiceHandler
 import software.aws.toolkits.jetbrains.services.telemetry.ClientMetadata
 import java.io.IOException
 import java.io.OutputStreamWriter
 import java.io.PipedInputStream
 import java.io.PipedOutputStream
 import java.io.PrintWriter
 import java.io.StringWriter
-import java.net.URI
 import java.nio.charset.StandardCharsets
 import java.util.concurrent.Future
 import kotlin.time.Duration.Companion.seconds
@@ -215,17 +215,6 @@
             }
         }
 
-    // needs case handling when project's base path is null: default projects/unit tests
-    private fun createWorkspaceFolders(): List<WorkspaceFolder> =
-        project.basePath?.let { basePath ->
-            listOf(
-                WorkspaceFolder(
-                    URI("file://$basePath").toString(),
-                    project.name
-                )
-            )
-        }.orEmpty() // no folders to report or workspace not folder based
-
     private fun createClientInfo(): ClientInfo {
         val metadata = ClientMetadata.getDefault()
         return ClientInfo().apply {
@@ -239,7 +228,7 @@
             processId = ProcessHandle.current().pid().toInt()
             capabilities = createClientCapabilities()
             clientInfo = createClientInfo()
-            workspaceFolders = createWorkspaceFolders()
+            workspaceFolders = createWorkspaceFolders(project)
             initializationOptions = createExtendedClientMetadata()
         }
 
@@ -306,6 +295,7 @@
         }
 
         DefaultAuthCredentialsService(project, encryptionManager, this)
+        WorkspaceServiceHandler(project, this)
     }
 
     override fun dispose() {

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

@@ -0,0 +1,22 @@
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.services.amazonq.lsp.util
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.ProjectRootManager
+import org.eclipse.lsp4j.WorkspaceFolder
+
+object WorkspaceFolderUtil {
+    fun createWorkspaceFolders(project: Project): List<WorkspaceFolder> =
+        if (project.isDefault) {
+            emptyList()
+        } else {
+            ProjectRootManager.getInstance(project).contentRoots.map { contentRoot ->
+                WorkspaceFolder().apply {
+                    name = contentRoot.name
+                    this.uri = contentRoot.url
+                }
+            }
+        }
+}

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

@@ -0,0 +1,164 @@
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.services.amazonq.lsp.workspace
+
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.ModuleRootEvent
+import com.intellij.openapi.roots.ModuleRootListener
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.openapi.vfs.VirtualFileManager
+import com.intellij.openapi.vfs.newvfs.BulkFileListener
+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 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.FileCreate
+import org.eclipse.lsp4j.FileDelete
+import org.eclipse.lsp4j.FileEvent
+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.Paths
+
+class WorkspaceServiceHandler(
+    private val project: Project,
+    serverInstance: Disposable,
+) : BulkFileListener,
+    ModuleRootListener {
+
+    private var lastSnapshot: List<WorkspaceFolder> = emptyList()
+    private val supportedFilePatterns = FileSystems.getDefault().getPathMatcher(
+        "glob:**/*.{ts,js,py,java}"
+    )
+
+    init {
+        project.messageBus.connect(serverInstance).subscribe(
+            VirtualFileManager.VFS_CHANGES,
+            this
+        )
+
+        project.messageBus.connect(serverInstance).subscribe(
+            ModuleRootListener.TOPIC,
+            this
+        )
+    }
+
+    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
+                file.toNioPath().toUri().toString().takeIf { it.isNotEmpty() }?.let { uri ->
+                    FileCreate().apply {
+                        this.uri = uri
+                    }
+                }
+            }
+
+            if (validFiles.isNotEmpty()) {
+                languageServer.workspaceService.didCreateFiles(
+                    CreateFilesParams().apply {
+                        files = validFiles
+                    }
+                )
+            }
+        }
+    }
+
+    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
+                file.toNioPath().toUri().toString().takeIf { it.isNotEmpty() }?.let { uri ->
+                    FileDelete().apply {
+                        this.uri = uri
+                    }
+                }
+            }
+
+            if (validFiles.isNotEmpty()) {
+                languageServer.workspaceService.didDeleteFiles(
+                    DeleteFilesParams().apply {
+                        files = validFiles
+                    }
+                )
+            }
+        }
+    }
+
+    private fun didChangeWatchedFiles(events: List<VFileEvent>) {
+        AmazonQLspService.executeIfRunning(project) { languageServer ->
+            val validChanges = events.mapNotNull { event ->
+                event.file?.toNioPath()?.toUri()?.toString()?.takeIf { it.isNotEmpty() }?.let { uri ->
+                    FileEvent().apply {
+                        this.uri = uri
+                        type = when (event) {
+                            is VFileCreateEvent -> FileChangeType.Created
+                            is VFileDeleteEvent -> FileChangeType.Deleted
+                            else -> FileChangeType.Changed
+                        }
+                    }
+                }
+            }
+
+            if (validChanges.isNotEmpty()) {
+                languageServer.workspaceService.didChangeWatchedFiles(
+                    DidChangeWatchedFilesParams().apply {
+                        changes = validChanges
+                    }
+                )
+            }
+        }
+    }
+
+    override fun after(events: List<VFileEvent>) {
+        // since we are using synchronous FileListener
+        pluginAwareExecuteOnPooledThread {
+            didCreateFiles(events.filterIsInstance<VFileCreateEvent>())
+            didDeleteFiles(events.filterIsInstance<VFileDeleteEvent>())
+            didChangeWatchedFiles(events)
+        }
+    }
+
+    override fun beforeRootsChange(event: ModuleRootEvent) {
+        lastSnapshot = createWorkspaceFolders(project)
+    }
+
+    override fun rootsChanged(event: ModuleRootEvent) {
+        AmazonQLspService.executeIfRunning(project) { languageServer ->
+            val currentSnapshot = createWorkspaceFolders(project)
+            val addedFolders = currentSnapshot.filter { folder -> lastSnapshot.none { it.uri == folder.uri } }
+            val removedFolders = lastSnapshot.filter { folder -> currentSnapshot.none { it.uri == folder.uri } }
+
+            if (addedFolders.isNotEmpty() || removedFolders.isNotEmpty()) {
+                languageServer.workspaceService.didChangeWorkspaceFolders(
+                    DidChangeWorkspaceFoldersParams().apply {
+                        this.event = WorkspaceFoldersChangeEvent().apply {
+                            added = addedFolders
+                            removed = removedFolders
+                        }
+                    }
+                )
+            }
+
+            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/util/WorkspaceFolderUtilTest.kt

@@ -0,0 +1,64 @@
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.services.amazonq.lsp.util
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.ProjectRootManager
+import com.intellij.openapi.vfs.VirtualFile
+import io.mockk.every
+import io.mockk.mockk
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class WorkspaceFolderUtilTest {
+
+    @Test
+    fun `createWorkspaceFolders returns empty list when no workspace folders`() {
+        val mockProject = mockk<Project>()
+        every { mockProject.isDefault } returns true
+
+        val result = WorkspaceFolderUtil.createWorkspaceFolders(mockProject)
+
+        assertEquals(emptyList<VirtualFile>(), result)
+    }
+
+    @Test
+    fun `createWorkspaceFolders returns workspace folders for non-default project`() {
+        val mockProject = mockk<Project>()
+        val mockProjectRootManager = mockk<ProjectRootManager>()
+        val mockContentRoot1 = mockk<VirtualFile>()
+        val mockContentRoot2 = mockk<VirtualFile>()
+
+        every { mockProject.isDefault } returns false
+        every { ProjectRootManager.getInstance(mockProject) } returns mockProjectRootManager
+        every { mockProjectRootManager.contentRoots } returns arrayOf(mockContentRoot1, mockContentRoot2)
+
+        every { mockContentRoot1.name } returns "root1"
+        every { mockContentRoot1.url } returns "file:///path/to/root1"
+        every { mockContentRoot2.name } returns "root2"
+        every { mockContentRoot2.url } returns "file:///path/to/root2"
+
+        val result = WorkspaceFolderUtil.createWorkspaceFolders(mockProject)
+
+        assertEquals(2, result.size)
+        assertEquals("file:///path/to/root1", result[0].uri)
+        assertEquals("file:///path/to/root2", result[1].uri)
+        assertEquals("root1", result[0].name)
+        assertEquals("root2", result[1].name)
+    }
+
+    @Test
+    fun `reateWorkspaceFolders returns empty list when project has no content roots`() {
+        val mockProject = mockk<Project>()
+        val mockProjectRootManager = mockk<ProjectRootManager>()
+
+        every { mockProject.isDefault } returns false
+        every { ProjectRootManager.getInstance(mockProject) } returns mockProjectRootManager
+        every { mockProjectRootManager.contentRoots } returns emptyArray()
+
+        val result = WorkspaceFolderUtil.createWorkspaceFolders(mockProject)
+
+        assertEquals(emptyList<VirtualFile>(), result)
+    }
+}