implement syncModuleDependencies logic

Author: samgst-amazon

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

@@ -44,6 +44,7 @@ import software.aws.toolkits.core.utils.info
 import software.aws.toolkits.core.utils.warn
 import software.aws.toolkits.jetbrains.isDeveloperMode
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.auth.DefaultAuthCredentialsService
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.dependencies.DefaultModuleDependenciesService
 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.textdocument.TextDocumentServiceHandler
@@ -143,7 +144,7 @@ class AmazonQLspService(private val project: Project, private val cs: CoroutineS
 
             try {
                 val i = it.await()
-                if (i.initializeResult.isActive) {
+                if (i.initializer.isActive) {
                     // not initialized
                     return
                 }
@@ -192,7 +193,7 @@ private class AmazonQServerInstance(private val project: Project, private val cs
     @Suppress("ForbiddenVoid")
     private val launcherFuture: Future<Void>
     private val launcherHandler: KillableProcessHandler
-    val initializeResult: Deferred<InitializeResult>
+    val initializer: Job
 
     private fun createClientCapabilities(): ClientCapabilities =
         ClientCapabilities().apply {
@@ -301,6 +302,7 @@ private class AmazonQServerInstance(private val project: Project, private val cs
         }
 
         DefaultAuthCredentialsService(project, encryptionManager, this)
+        DefaultModuleDependenciesService(project, this)
         TextDocumentServiceHandler(project, this)
         WorkspaceServiceHandler(project, this)
     }

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

@@ -3,23 +3,129 @@
 
 package software.aws.toolkits.jetbrains.services.amazonq.lsp.dependencies
 
+import com.intellij.openapi.Disposable
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.roots.ModuleRootEvent
+import com.intellij.openapi.roots.ModuleRootListener
+import com.intellij.openapi.module.ModuleManager
+import com.intellij.openapi.projectRoots.JavaSdkType
+import com.intellij.openapi.roots.ModuleRootManager
+import com.intellij.openapi.roots.OrderRootType
+import com.intellij.openapi.vfs.VfsUtil
+import com.jetbrains.python.packaging.management.PythonPackageManager
+import com.jetbrains.python.sdk.PythonSdkUtil
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.AmazonQLspService
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.dependencies.SyncModuleDependenciesParams
 
-class DefaultModuleDependenciesService(private val project: Project) : ModuleDependenciesService {
+class DefaultModuleDependenciesService(
+    private val project: Project,
+    serverInstance: Disposable
+) : ModuleDependenciesService,
+    ModuleRootListener
+{
+
+    init {
+        project.messageBus.connect(serverInstance).subscribe(
+            ModuleRootListener.TOPIC,
+            this
+        )
+        // project initiation with initial list of dependencies
+        syncAllModules()
+    }
+
+
+    override fun rootsChanged(event: ModuleRootEvent) {
+        if (event.isCausedByFileTypesChange) return
+        // call on change with updated dependencies
+        syncAllModules()
+    }
+
 
-//    init {
-        // TODO: add moduleRootListener to make function call that eventually sends message w/ params
-//    }
 
     override fun syncModuleDependencies(params: SyncModuleDependenciesParams) {
         AmazonQLspService.executeIfRunning(project) { languageServer ->
             languageServer.syncModuleDependencies(params)
         }
     }
 
-//    fun createSyncModuleDependenciesParams() :  SyncModuleDependenciesParams {
-//        return SyncModuleDependenciesParams()
-//    }
+    private fun syncAllModules() {
+        ModuleManager.getInstance(project).modules.forEach { module ->
+            val language = getModuleLanguage(module)
+            val params = when (language) {
+                "Java" -> createJavaParams(module)
+                "Python" -> createPythonParams(module)
+                else -> return
+            }
+            syncModuleDependencies(params)
+        }
+
+    }
+
+    private fun getModuleLanguage(module: Module): String {
+        return when {
+            ModuleRootManager.getInstance(module).sdk?.sdkType is JavaSdkType -> "Java"
+            PythonSdkUtil.findPythonSdk(module) != null -> "Python"
+            else -> "Unknown"
+        }
+    }
+
+    private fun getSourceRoots(module: Module): List<String> {
+        val sourceRoots = mutableListOf<String>()
+
+        // Get all source roots from content entries
+        ModuleRootManager.getInstance(module).contentEntries
+            .flatMap { contentEntry ->
+                contentEntry.sourceFolders
+                    .filter { !it.isTestSource }
+                    .mapNotNull { it.file?.path }
+            }
+            .forEach { path -> sourceRoots.add(path) }
+
+        return sourceRoots
+    }
+
+    private fun createJavaParams(module: Module): SyncModuleDependenciesParams {
+        val sourceRoots = getSourceRoots(module)
+        val dependencies = mutableListOf<String>()
+
+        // Get library dependencies
+        ModuleRootManager.getInstance(module).orderEntries().forEachLibrary { library ->
+            library.getUrls(OrderRootType.CLASSES).forEach { url ->
+                dependencies.add(VfsUtil.urlToPath(url))
+            }
+            true
+        }
+
+        return SyncModuleDependenciesParams(
+            moduleName = module.name,
+            programmingLanguage = "Java",
+            files = sourceRoots,
+            dirs = dependencies,
+            includePatterns = emptyList(),
+            excludePatterns = emptyList()
+        )
+    }
+
+    private fun createPythonParams(module: Module): SyncModuleDependenciesParams {
+        val sourceRoots = getSourceRoots(module)
+        val dependencies = mutableListOf<String>()
+
+        // Get Python packages
+        PythonSdkUtil.findPythonSdk(module)?.let { sdk ->
+            val packageManager = PythonPackageManager.forSdk(module.project, sdk)
+            packageManager.installedPackages.forEach { pkg ->
+                dependencies.add(pkg.name)
+            }
+        }
+
+        return SyncModuleDependenciesParams(
+            moduleName = module.name,
+            programmingLanguage = "Python",
+            files = sourceRoots,
+            dirs = dependencies,
+            includePatterns = emptyList(),
+            excludePatterns = emptyList()
+        )
+    }
 }