Phase 3: device profiler and tier matrix

app/src/main/java/io/github/abrarul/modularai/model/DeviceProfiler.kt

@@ -0,0 +1,100 @@
+package io.github.abrarul.modularai.model
+
+import android.app.ActivityManager
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Environment
+import android.os.StatFs
+import java.io.File
+import kotlin.system.measureTimeMillis
+
+enum class Tier(val label: String, val sizes: String) {
+    ULTRA_LIGHT("Ultra-Light", "1B-3B"),
+    BALANCED("Balanced", "7B-8B"),
+    POWER("Power", "14B+")
+}
+
+data class Profile(
+    val soc: String,
+    val abi: String,
+    val cores: Int,
+    val totalRamMb: Long,
+    val availRamMb: Long,
+    val freeStorageMb: Long,
+    val vulkan: Boolean,
+    val storageMBps: Double,
+    val tier: Tier
+)
+
+data class Recommendation(
+    val tier: Tier,
+    val maxParamsB: Double,
+    val quant: String,
+    val contextTokens: Int,
+    val estTokensPerSec: String
+)
+
+object DeviceProfiler {
+
+    fun scan(ctx: Context): Profile {
+        val am = ctx.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+        val mi = ActivityManager.MemoryInfo().also { am.getMemoryInfo(it) }
+        val total = mi.totalMem / 1_048_576
+        val stat = StatFs(Environment.getDataDirectory().path)
+        val soc = if (Build.VERSION.SDK_INT >= 31) "${Build.SOC_MANUFACTURER} ${Build.SOC_MODEL}" else Build.HARDWARE
+        return Profile(
+            soc = soc,
+            abi = Build.SUPPORTED_ABIS.firstOrNull() ?: "unknown",
+            cores = Runtime.getRuntime().availableProcessors(),
+            totalRamMb = total,
+            availRamMb = mi.availMem / 1_048_576,
+            freeStorageMb = stat.availableBytes / 1_048_576,
+            vulkan = ctx.packageManager.hasSystemFeature(PackageManager.FEATURE_VULKAN_HARDWARE_LEVEL),
+            storageMBps = benchStorage(ctx.cacheDir),
+            tier = when {
+                total < 5_000 -> Tier.ULTRA_LIGHT
+                total < 10_000 -> Tier.BALANCED
+                else -> Tier.POWER
+            }
+        )
+    }
+
+    /** 32 MB sequential write benchmark. */
+    private fun benchStorage(dir: File): Double {
+        val f = File(dir, "bench.tmp")
+        val buf = ByteArray(1 shl 20)
+        val ms = measureTimeMillis {
+            f.outputStream().use { o -> repeat(32) { o.write(buf) }; o.fd.sync() }
+        }
+        f.delete()
+        return if (ms == 0L) 0.0 else 32_000.0 / ms
+    }
+
+    /**
+     * Heuristic: a Q4_K_M GGUF needs roughly 0.6 GB per billion params plus KV cache.
+     * Uses ~60% of currently available RAM as the budget. Tokens/s is a rough estimate only;
+     * real numbers come from the in-app benchmark.
+     */
+    fun recommend(p: Profile): Recommendation {
+        val budgetGb = p.availRamMb * 0.6 / 1024.0
+        val maxB = ((budgetGb - 0.5) / 0.6).coerceAtLeast(0.5)
+        val quant = when {
+            maxB >= 8 -> "Q5_K_M"
+            maxB >= 3 -> "Q4_K_M"
+            maxB >= 1.5 -> "Q4_K_S"
+            else -> "IQ2_XS"
+        }
+        val ctxTokens = when {
+            budgetGb >= 8 -> 8192
+            budgetGb >= 4 -> 4096
+            else -> 2048
+        }
+        val tps = when (p.tier) {
+            Tier.ULTRA_LIGHT -> "3-10"
+            Tier.BALANCED -> "2-8"
+            Tier.POWER -> "3-12"
+        }
+        return Recommendation(p.tier, maxB, quant, ctxTokens, tps)
+    }
+}