feat: add AVD, system image, Gradle caches, daemons, and JDKs to workspace analyzer and cleanups

Author: Coding-Meet

composeApp/build.gradle.kts

@@ -197,6 +197,7 @@ compose {
                     iconFile.set(iconsRoot.resolve("app_logo.png"))
                     shortcut = true
                     appCategory = "Productivity"
+                    modules("jdk.security.auth")
                 }
 
             }

composeApp/compose-desktop.pro

@@ -144,4 +144,13 @@
 -dontwarn org.codehaus.mojo.animal_sniffer.**
 -dontwarn com.jetbrains.SharedTextures
 
--adaptresourcefilenames okhttp3/internal/publicsuffix/PublicSuffixDatabase.gz
+-adaptresourcefilenames okhttp3/internal/publicsuffix/PublicSuffixDatabase.gz
+
+# Required on JVM for JNA-based integrations.
+-keep class com.sun.jna.** { *; }
+-keep class * implements com.sun.jna.** { *; }
+
+# Required when using FileKit Dialogs on Linux (XDG Desktop Portal / DBus).
+-keep class org.freedesktop.dbus.** { *; }
+-keep class io.github.vinceglb.filekit.dialogs.platform.xdg.** { *; }
+-keepattributes Signature,InnerClasses,RuntimeVisibleAnnotations

composeApp/src/jvmMain/kotlin/com/meet/dev/analyzer/data/models/project/ProjectOverviewInfo.kt

@@ -16,4 +16,6 @@ data class ProjectOverviewInfo(
     val ndkVersion: String?,
     val cmakeVersion: String?,
     val platformList: List<String>,
+    val jdkVersion: String?,
+    val buildDsl: String?,
 )

composeApp/src/jvmMain/kotlin/com/meet/dev/analyzer/data/models/workspace/WorkspaceUsageAnalysis.kt

@@ -41,6 +41,34 @@ enum class ResourceCategory(
     ANDROID_SDK_SOURCES(
         displayName = "Android SDK Sources",
         description = "Source code downloads for Android APIs, used for reference in the IDE. Safe to delete if not used."
+    ),
+    ANDROID_AVD(
+        displayName = "Android Virtual Devices (AVD)",
+        description = "Configured emulator virtual devices. Deleting them removes the AVD and its virtual storage disk."
+    ),
+    ANDROID_SYSTEM_IMAGE(
+        displayName = "Android System Images",
+        description = "Downloaded Android system images (grouped by API level) used to run AVDs. Older or unused images can be safely deleted."
+    ),
+    GRADLE_DAEMON(
+        displayName = "Gradle Daemons",
+        description = "Gradle daemon process logs and registry files. Deleting them is completely safe and cleans up system clutter."
+    ),
+    GRADLE_BUILD_CACHE(
+        displayName = "Gradle Build Cache",
+        description = "Cached task outputs for Gradle builds. Safe to delete; Gradle will rebuild tasks on demand."
+    ),
+    GRADLE_TRANSFORMS_CACHE(
+        displayName = "Gradle Transforms & Jars Cache",
+        description = "Intermediate transformed dependency artifacts. Safe to delete; Gradle will regenerate them on the next compilation."
+    ),
+    GRADLE_TEMP_FILES(
+        displayName = "Gradle Temporary Files",
+        description = "Leftover temporary files generated during project builds. Completely safe to delete."
+    ),
+    GRADLE_JDK(
+        displayName = "Gradle Toolchain JDKs",
+        description = "JDK versions automatically downloaded by Gradle to run your projects. Deleting them is safe; Gradle will re-download them if needed."
     )
 }
 

composeApp/src/jvmMain/kotlin/com/meet/dev/analyzer/data/repository/project/helpers/ProjectOverviewAnalyzer.kt

@@ -5,6 +5,7 @@ import com.meet.dev.analyzer.data.models.project.ModuleBuildFileInfo
 import com.meet.dev.analyzer.data.models.project.ProjectOverviewInfo
 import com.meet.dev.analyzer.data.models.project.SettingsGradleFileInfo
 import com.meet.dev.analyzer.data.models.project.VersionCatalog
+import com.meet.dev.analyzer.data.models.project.BuildFileType
 import com.meet.dev.analyzer.utility.crash_report.AppLogger
 import com.meet.dev.analyzer.utility.crash_report.AppLogger.tagName
 import com.meet.dev.analyzer.utility.platform.FolderFileUtils
@@ -24,11 +25,16 @@ class ProjectOverviewAnalyzer {
 
         fun findProjectName(): String {
             if (settingsGradleFileInfo == null) return projectDir.name
-            val readLines = settingsGradleFileInfo.readLines
-            val projectNameLine = readLines.find { it.startsWith("rootProject.name") }
-            if (projectNameLine == null) return projectDir.name
-            val projectName = projectNameLine.substringAfter("=").replace("\"", "").trim()
-            return projectName
+            val regex = Regex("""rootProject\.name\s*=\s*['"]([^'"]+)['"]""")
+            settingsGradleFileInfo.readLines.forEach { line ->
+                val trimmed = line.trim()
+                if (!trimmed.startsWith("//") && !trimmed.startsWith("/*")) {
+                    regex.find(trimmed)?.let { match ->
+                        return match.groupValues[1].trim()
+                    }
+                }
+            }
+            return projectDir.name
         }
 
         val rootModuleBuildFileInfo =
@@ -208,6 +214,58 @@ class ProjectOverviewAnalyzer {
             return platforms.toList()
         }
 
+        fun extractJdkVersion(): String? {
+            moduleBuildFileInfos.forEach { file ->
+                val content = file.content
+
+                // Case 1: jvmToolchain(17) or jvmToolchain = 17
+                Regex("""jvmToolchain\s*\(?\s*(\d+)\s*\)?""").find(content)?.let {
+                    return it.groupValues[1]
+                }
+
+                // Case 2: languageVersion = JavaLanguageVersion.of(17)
+                Regex("""languageVersion\s*=\s*JavaLanguageVersion\.of\s*\(\s*(\d+)\s*\)""").find(content)?.let {
+                    return it.groupValues[1]
+                }
+
+                // Case 3: JavaVersion.VERSION_1_X or JavaVersion.VERSION_X
+                Regex("""JavaVersion\.VERSION_1_(\d+)""").find(content)?.let {
+                    return it.groupValues[1]
+                }
+                Regex("""JavaVersion\.VERSION_(\d+)""").find(content)?.let {
+                    return it.groupValues[1]
+                }
+
+                // Case 4: jvmTarget = "17" or jvmTarget = "1.8"
+                Regex("""jvmTarget\s*=\s*["']1\.(\d+)["']""").find(content)?.let {
+                    return it.groupValues[1]
+                }
+                Regex("""jvmTarget\s*=\s*["'](\d+)["']""").find(content)?.let {
+                    return it.groupValues[1]
+                }
+            }
+
+            val propertiesFile = File(projectDir, "gradle.properties")
+            if (propertiesFile.exists()) {
+                try {
+                    val lines = propertiesFile.readLines()
+                    lines.find { it.contains("org.gradle.java.home") }?.let { line ->
+                        val path = line.substringAfter("=").trim()
+                        val dirName = File(path).name
+                        val versionRegex = Regex("""(\d+)""")
+                        versionRegex.find(dirName)?.value?.let { return it }
+                    }
+                } catch (_: Exception) {}
+            }
+
+            return null
+        }
+
+        fun extractBuildDsl(): String {
+            val hasKts = moduleBuildFileInfos.any { it.type == BuildFileType.BUILD_GRADLE_KTS }
+            return if (hasKts) "Kotlin DSL" else "Groovy DSL"
+        }
+
         val sizeBytes = FolderFileUtils.calculateFolderSize(projectDir)
 
         val projectOverviewInfo = ProjectOverviewInfo(
@@ -225,7 +283,9 @@ class ProjectOverviewAnalyzer {
             compileSdkVersion = extractCompileSdk(),
             ndkVersion = extractNdkVersion(),
             cmakeVersion = extractCmakeVersion(),
-            platformList = getPlatforms()
+            platformList = getPlatforms(),
+            jdkVersion = extractJdkVersion(),
+            buildDsl = extractBuildDsl()
         )
         AppLogger.d(tag = tag) { "Found project info." }
         AppLogger.i(tag = tag) {

composeApp/src/jvmMain/kotlin/com/meet/dev/analyzer/data/repository/workspace/WorkspaceRepositoryImpl.kt

@@ -8,6 +8,7 @@ import com.meet.dev.analyzer.data.repository.project.helpers.ProjectFileScanner
 import com.meet.dev.analyzer.data.repository.project.helpers.ProjectOverviewAnalyzer
 import com.meet.dev.analyzer.data.repository.project.helpers.VersionCatalogParser
 import com.meet.dev.analyzer.data.repository.storage.helpers.AndroidSdkAnalyzer
+import com.meet.dev.analyzer.data.repository.storage.helpers.AvdAnalyzer
 import com.meet.dev.analyzer.data.repository.storage.helpers.GradleAnalyzer
 import com.meet.dev.analyzer.data.repository.storage.helpers.KonanAnalyzer
 import com.meet.dev.analyzer.utility.crash_report.AppLogger
@@ -23,7 +24,8 @@ class WorkspaceRepositoryImpl(
     private val projectOverviewAnalyzer: ProjectOverviewAnalyzer,
     private val androidSdkAnalyzer: AndroidSdkAnalyzer,
     private val gradleAnalyzer: GradleAnalyzer,
-    private val konanAnalyzer: KonanAnalyzer
+    private val konanAnalyzer: KonanAnalyzer,
+    private val avdAnalyzer: AvdAnalyzer
 ) : WorkspaceRepository {
 
     private val TAG = tagName(javaClass)
@@ -58,6 +60,7 @@ class WorkspaceRepositoryImpl(
             val usedKotlinVersions = mutableSetOf<String>()
             val usedNdkVersions = mutableSetOf<String>()
             val usedCmakeVersions = mutableSetOf<String>()
+            val usedJdkVersions = mutableSetOf<String>()
 
             projectDirs.forEachIndexed { index, projectDir ->
                 val progressVal = 0.1f + (0.5f * (index.toFloat() / totalProjects))
@@ -93,6 +96,7 @@ class WorkspaceRepositoryImpl(
                 overview.kotlinVersion?.let { usedKotlinVersions.add(it) }
                 overview.ndkVersion?.let { usedNdkVersions.add(it) }
                 overview.cmakeVersion?.let { usedCmakeVersions.add(it) }
+                overview.jdkVersion?.let { usedJdkVersions.add(it) }
             }
 
             AppLogger.i(TAG) {
@@ -102,7 +106,8 @@ class WorkspaceRepositoryImpl(
                         "Gradle: $usedGradleVersions\n" +
                         "Kotlin: $usedKotlinVersions\n" +
                         "NDK: $usedNdkVersions\n" +
-                        "CMake: $usedCmakeVersions"
+                        "CMake: $usedCmakeVersions\n" +
+                        "JDK: $usedJdkVersions"
             }
 
             // 2. Scan Local System Resources
@@ -316,6 +321,130 @@ class WorkspaceRepositoryImpl(
                 if (isUsed) activeResources.add(resource) else unusedResources.add(resource)
             }
 
+            // 2.i Android Virtual Devices
+            onProgress(0.97f, "Scanning Android Virtual Devices...")
+            val avdInfo = avdAnalyzer.analyzeAvdData()
+            avdInfo.avdItemList.forEach { item ->
+                unusedResources.add(
+                    UnusedResourceItem(
+                        name = item.name,
+                        version = item.apiLevel ?: "Unknown",
+                        category = ResourceCategory.ANDROID_AVD,
+                        path = item.path,
+                        sizeBytes = item.sizeBytes,
+                        sizeFormatted = item.actualStorage,
+                        usedByProjects = emptyList()
+                    )
+                )
+            }
+
+            // 2.j Android System Images
+            onProgress(0.98f, "Scanning Android System Images...")
+            sdkInfo.systemImageInfo.systemImages.forEach { item ->
+                val apiVal = apiRegex.find(item.name)?.groupValues?.get(1)
+                    ?: item.name.substringAfter("android-")
+
+                val usedByAnyProject = usedCompileSdks.contains(apiVal) ||
+                        usedCompileSdks.any { it.contains(apiVal) } ||
+                        usedTargetSdks.contains(apiVal) ||
+                        usedTargetSdks.any { it.contains(apiVal) } ||
+                        usedMinSdks.contains(apiVal) ||
+                        usedMinSdks.any { it.contains(apiVal) }
+
+                val usedByAnyAvd = avdInfo.avdItemList.any { avd ->
+                    avd.apiLevel == apiVal || avd.apiLevel == "android-$apiVal"
+                }
+
+                val isUsed = usedByAnyProject || usedByAnyAvd
+                val usingProjects = if (usedByAnyProject) {
+                    projects.filter {
+                        it.compileSdkVersion == apiVal || it.compileSdkVersion?.contains(apiVal) == true ||
+                                it.targetSdkVersion == apiVal || it.targetSdkVersion?.contains(apiVal) == true ||
+                                it.minSdkVersion == apiVal || it.minSdkVersion?.contains(apiVal) == true
+                    }.map { it.projectName }
+                } else emptyList()
+
+                val resource = UnusedResourceItem(
+                    name = "System Image ${item.name}",
+                    version = apiVal,
+                    category = ResourceCategory.ANDROID_SYSTEM_IMAGE,
+                    path = item.path,
+                    sizeBytes = item.sizeBytes,
+                    sizeFormatted = item.sizeReadable,
+                    usedByProjects = usingProjects
+                )
+                if (isUsed) activeResources.add(resource) else unusedResources.add(resource)
+            }
+
+            // 2.k Gradle Daemons
+            onProgress(0.86f, "Scanning Gradle daemons...")
+            gradleInfo.daemonInfo.daemonItems.forEach { item ->
+                unusedResources.add(
+                    UnusedResourceItem(
+                        name = "Gradle Daemon Logs ${item.name}",
+                        version = item.name,
+                        category = ResourceCategory.GRADLE_DAEMON,
+                        path = item.path,
+                        sizeBytes = item.sizeBytes,
+                        sizeFormatted = item.sizeReadable
+                    )
+                )
+            }
+
+            // 2.l Gradle Toolchain JDKs
+            onProgress(0.87f, "Scanning Gradle JDKs...")
+            gradleInfo.jdkInfo.jdkItems.forEach { item ->
+                val version = item.name
+                val isUsed = usedJdkVersions.any { usedVer ->
+                    version.contains(usedVer) || usedVer.contains(version)
+                }
+                val usingProjects = if (isUsed) {
+                    projects.filter {
+                        it.jdkVersion != null && (version.contains(it.jdkVersion) || it.jdkVersion.contains(version))
+                    }.map { it.projectName }
+                } else emptyList()
+
+                val resource = UnusedResourceItem(
+                    name = "Gradle Toolchain JDK ${item.name}",
+                    version = item.name,
+                    category = ResourceCategory.GRADLE_JDK,
+                    path = item.path,
+                    sizeBytes = item.sizeBytes,
+                    sizeFormatted = item.sizeReadable,
+                    usedByProjects = usingProjects
+                )
+                if (isUsed) activeResources.add(resource) else unusedResources.add(resource)
+            }
+
+            // 2.m Other Gradle Caches & Temp Files
+            onProgress(0.88f, "Scanning other Gradle caches...")
+            gradleInfo.otherGradleFolderInfo.otherGradleFolderItems.forEach { item ->
+                val category = when (item.version) {
+                    ".tmp" -> ResourceCategory.GRADLE_TEMP_FILES
+                    "build-cache-1" -> ResourceCategory.GRADLE_BUILD_CACHE
+                    "transforms-3", "jars-9" -> ResourceCategory.GRADLE_TRANSFORMS_CACHE
+                    else -> null
+                }
+                if (category != null) {
+                    unusedResources.add(
+                        UnusedResourceItem(
+                            name = when (item.version) {
+                                ".tmp" -> "Gradle Temporary Files"
+                                "build-cache-1" -> "Gradle Local Build Cache"
+                                "transforms-3" -> "Gradle Dependency Transforms Cache"
+                                "jars-9" -> "Gradle Cached Jars"
+                                else -> item.version
+                            },
+                            version = "Global",
+                            category = category,
+                            path = item.path,
+                            sizeBytes = item.sizeBytes,
+                            sizeFormatted = item.sizeReadable
+                        )
+                    )
+                }
+            }
+
             onProgress(1f, "Analysis Complete")
             WorkspaceAnalysisResult(
                 projects = projects,
@@ -337,6 +466,13 @@ class WorkspaceRepositoryImpl(
                 } else {
                     val success = file.deleteRecursively()
                     if (success) {
+                        if (file.name.endsWith(".avd", ignoreCase = true)) {
+                            val parent = file.parentFile
+                            val iniFile = File(parent, file.nameWithoutExtension + ".ini")
+                            if (iniFile.exists()) {
+                                iniFile.delete()
+                            }
+                        }
                         Pair(true, null)
                     } else {
                         Pair(

composeApp/src/jvmMain/kotlin/com/meet/dev/analyzer/presentation/screen/cleanbuild/CleanBuildViewModel.kt

@@ -278,7 +278,8 @@ class CleanBuildViewModel(
                 expandedProjects = emptySet(),
                 selectedPath = "",
                 deletionProgressList = emptyList(),
-                deletionResult = ""
+                deletionResult = "",
+                isProjectSelectionExpanded = true
             )
         }
     }
@@ -344,7 +345,8 @@ class CleanBuildViewModel(
                         isAnalyzing = false,
                         scanProgress = 1f,
                         scanStatus = if (result.isEmpty()) "No Gradle projects found" else "Done",
-                        expandedProjects = expandedProjects
+                        expandedProjects = expandedProjects,
+                        isProjectSelectionExpanded = if (result.isEmpty()) true else it.isProjectSelectionExpanded
                     )
                 }
                 val durationMs = mark.elapsedNow().inWholeMilliseconds

composeApp/src/jvmMain/kotlin/com/meet/dev/analyzer/presentation/screen/project/components/ProjectOverviewTabContent.kt

@@ -175,7 +175,9 @@ private fun ProjectConfigurationCard(projectOverviewInfo: ProjectOverviewInfo) {
         ProjectDetail("Build Tools", projectOverviewInfo.buildToolsSdk),
         ProjectDetail("Multi-Module", if (projectOverviewInfo.isMultiModule) "Yes" else "No"),
         ProjectDetail("NDK", projectOverviewInfo.ndkVersion),
-        ProjectDetail("CMake", projectOverviewInfo.cmakeVersion)
+        ProjectDetail("CMake", projectOverviewInfo.cmakeVersion),
+        ProjectDetail("JDK", projectOverviewInfo.jdkVersion),
+        ProjectDetail("Build DSL", projectOverviewInfo.buildDsl)
     )
 
     OutlinedCard(
@@ -195,7 +197,7 @@ private fun ProjectConfigurationCard(projectOverviewInfo: ProjectOverviewInfo) {
             )
             DetailGrid(
                 items = configurationItems,
-                columnCount = 5
+                columnCount = 4
             )
         }