feat: add support for Linux directory paths and storage analysis

- Add default JetBrains and Google paths for Linux and macOS
- Update storage analysis logic to handle Linux-specific directory structures
- Implement conditional path resolution for logs and caches on Linux
- Refactor scanning logic to distinguish between operating systems during analysis

Author: Coding-Meet

composeApp/src/jvmMain/kotlin/com/meet/dev/analyzer/core/utility/DefaultPath.kt

@@ -47,12 +47,17 @@ fun getDefaultJetbrainsFolderPaths(): List<String> {
             "$userHome\\AppData\\Local\\JetBrains",
             "$userHome\\AppData\\Roaming\\JetBrains"
         )
-
-        else -> listOf(
+        os.contains("mac") -> listOf(
             "$userHome/Library/Caches/JetBrains",
             "$userHome/Library/Logs/JetBrains",
             "$userHome/Library/Application Support/JetBrains"
         )
+
+        else -> listOf( // Linux / Unix
+            "$userHome/.cache/JetBrains",
+            "$userHome/.cache/JetBrains",
+            "$userHome/.config/JetBrains"
+        )
     }
 }
 
@@ -66,11 +71,17 @@ fun getDefaultGoogleFolderPaths(): List<String> {
             "$userHome\\AppData\\Roaming\\Google"
         )
 
-        else -> listOf(
+        os.contains("mac") -> listOf(
             "$userHome/Library/Caches/Google",
             "$userHome/Library/Logs/Google",
             "$userHome/Library/Application Support/Google"
         )
+
+        else -> listOf( // Linux / Unix
+            "$userHome/.cache/Google",
+            "$userHome/.cache/Google",
+            "$userHome/.config/Google"
+        )
     }
 }
 

composeApp/src/jvmMain/kotlin/com/meet/dev/analyzer/data/repository/storage/StorageAnalyzerRepositoryImpl.kt

@@ -76,26 +76,45 @@ class StorageAnalyzerRepositoryImpl(
         fun scanBase(
             vendor: String,
             category: String,
-            basePath: String
+            basePath: String,
+            isLinux: Boolean
         ): List<IdeInstallation> {
             val dir = File(basePath)
             return dir.listFiles()
                 ?.filter { it.isDirectory && it.name.any { ch -> ch.isDigit() } }
-                ?.mapNotNull { file ->
-                    val sizeBytes = Utils.calculateFolderSize(file)
-                    val sizeReadable = Utils.formatSize(sizeBytes)
-                    val info = extractIdeNameAndVersionByFirstDigit(file.name)
-                    val (ideName, version) = info
+                ?.mapNotNull { ideDir ->
+                    val targetDir = when {
+                        isLinux && category == "LOGS" ->
+                            File(ideDir, "log")
 
+                        else ->
+                            ideDir
+                    }
+
+                    if (!targetDir.exists()) return@mapNotNull null
+
+                    val sizeBytes = when {
+                        isLinux && category == "CACHES" ->
+                            ideDir.listFiles()
+                                ?.filter { it.name != "log" }
+                                ?.sumOf { Utils.calculateFolderSize(it) }
+                                ?: 0L
+
+                        else ->
+                            Utils.calculateFolderSize(targetDir)
+                    }
+
+                    val (ideName, version) =
+                        extractIdeNameAndVersionByFirstDigit(ideDir.name)
                     IdeInstallation(
-                        name = file.name,
+                        name = ideDir.name,
                         ideName = ideName,
                         version = version,
                         category = category,
-                        path = file.absolutePath,
+                        path = targetDir.absolutePath,
                         sizeBytes = sizeBytes,
-                        vendor = vendor,
-                        sizeReadable = sizeReadable
+                        sizeReadable = Utils.formatSize(sizeBytes),
+                        vendor = vendor
                     )
                 } ?: emptyList()
         }
@@ -140,12 +159,20 @@ class StorageAnalyzerRepositoryImpl(
         try {
             val os = System.getProperty("os.name").lowercase()
             val isWindows = os.contains("windows")
+            val isLinux = !os.contains("windows") && !os.contains("mac")
             val basePaths = buildBasePaths(isWindows = isWindows)
 
             val allInstallations = buildList {
                 basePaths.forEach { (vendor, categories) ->
                     categories.forEach { (category, path) ->
-                        addAll(scanBase(vendor, category, path))
+                        addAll(
+                            scanBase(
+                                vendor = vendor,
+                                category = category,
+                                basePath = path,
+                                isLinux = isLinux
+                            )
+                        )
                     }
                 }
             }