create-cmp-cli 0.2.0

package/template/composeApp/build.gradle.kts

@@ -0,0 +1,257 @@
+import org.jetbrains.compose.resources.ResourcesExtension
+import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    alias(libs.plugins.kotlin.multiplatform)
+    alias(libs.plugins.kotlin.serialization)
+    alias(libs.plugins.compose.multiplatform)
+    alias(libs.plugins.compose.compiler)
+    alias(libs.plugins.android.application)
+    // >>> cmp:feature firebase
+    alias(libs.plugins.google.services)
+    // <<< cmp:feature firebase
+    // >>> cmp:feature room
+    alias(libs.plugins.ksp)
+    alias(libs.plugins.room)
+    // <<< cmp:feature room
+    // >>> cmp:feature dev-client
+    alias(libs.plugins.compose.hot.reload)
+    // <<< cmp:feature dev-client
+}
+
+kotlin {
+    compilerOptions {
+        // kotlinx-datetime 0.7.x Clock/Instant delegate to the experimental kotlin.time
+        // types on Kotlin 2.2.20; opt in project-wide.
+        optIn.add("kotlin.time.ExperimentalTime")
+        // >>> cmp:feature ios
+        // iosMain cinterop Foreign APIs (NWPathMonitor, NSHomeDirectory, etc.)
+        optIn.add("kotlinx.cinterop.ExperimentalForeignApi")
+        // <<< cmp:feature ios
+    }
+
+    androidTarget {
+        @OptIn(ExperimentalKotlinGradlePluginApi::class)
+        compilerOptions {
+            jvmTarget.set(JvmTarget.JVM_17)
+        }
+    }
+
+    // >>> cmp:feature ios
+    listOf(
+        iosX64(),
+        iosArm64(),
+        iosSimulatorArm64()
+    ).forEach { iosTarget ->
+        iosTarget.binaries.framework {
+            baseName = "ComposeApp"
+            isStatic = true
+        }
+    }
+    // <<< cmp:feature ios
+
+    // >>> cmp:feature dev-client
+    // Desktop dev-client: runs the shared commonMain UI in a live JVM window — the daily dev
+    // loop. Compose Hot Reload attaches to this target (task: hotRunDesktop). See docs/dev-client.md.
+    jvm("desktop") {
+        @OptIn(ExperimentalKotlinGradlePluginApi::class)
+        compilerOptions {
+            jvmTarget.set(JvmTarget.JVM_17)
+        }
+    }
+    // <<< cmp:feature dev-client
+
+    sourceSets {
+        commonMain.dependencies {
+            implementation(compose.runtime)
+            implementation(compose.foundation)
+            implementation(compose.material3)
+            implementation(compose.materialIconsExtended)
+            implementation(compose.ui)
+            implementation(compose.components.resources)
+
+            // Lifecycle / ViewModel
+            implementation(libs.lifecycle.viewmodel)
+            implementation(libs.lifecycle.viewmodel.compose)
+            implementation(libs.lifecycle.runtime.compose)
+
+            // Navigation
+            implementation(libs.navigation.compose)
+
+            // Koin DI
+            implementation(libs.koin.core)
+            implementation(libs.koin.compose)
+            implementation(libs.koin.compose.viewmodel)
+
+            // Ktor
+            implementation(libs.ktor.client.core)
+            implementation(libs.ktor.client.content.negotiation)
+            implementation(libs.ktor.serialization.kotlinx.json)
+
+            // >>> cmp:feature firebase
+            implementation(libs.firebase.auth)
+            implementation(libs.firebase.firestore)
+            implementation(libs.firebase.functions)
+            implementation(libs.firebase.storage)
+            implementation(libs.firebase.messaging)
+            implementation(libs.firebase.config)
+            // <<< cmp:feature firebase
+
+            // >>> cmp:feature room
+            implementation(libs.room.runtime)
+            implementation(libs.sqlite.bundled)
+            // <<< cmp:feature room
+
+            // Kotlinx
+            implementation(libs.kotlinx.serialization.json)
+            implementation(libs.kotlinx.datetime)
+            implementation(libs.kotlinx.coroutines.core)
+
+            // Coil image loading
+            implementation(libs.coil.compose)
+            implementation(libs.coil.network.ktor)
+        }
+
+        androidMain.dependencies {
+            implementation(libs.androidx.core.ktx)
+            implementation(libs.androidx.activity.compose)
+            implementation(libs.ktor.client.cio)
+            implementation(libs.koin.android)
+            implementation(libs.kotlinx.coroutines.android)
+            // >>> cmp:feature room
+            implementation(libs.room.runtime.android)
+            // <<< cmp:feature room
+        }
+
+        // >>> cmp:feature ios
+        iosMain.dependencies {
+            implementation(libs.ktor.client.darwin)
+        }
+        // <<< cmp:feature ios
+
+        // >>> cmp:feature dev-client
+        val desktopMain by getting {
+            dependencies {
+                implementation(compose.desktop.currentOs)
+                implementation(libs.kotlinx.coroutines.swing)
+                implementation(libs.ktor.client.cio)
+            }
+        }
+        // <<< cmp:feature dev-client
+
+        commonTest.dependencies {
+            implementation(libs.kotlin.test)
+            implementation(libs.koin.test)
+            implementation(libs.kotlinx.coroutines.test)
+        }
+    }
+}
+
+android {
+    namespace = "__PACKAGE__"
+    compileSdk = 35
+
+    defaultConfig {
+        applicationId = "__PACKAGE__"
+        minSdk = 24
+        targetSdk = 35
+        versionCode = 1
+        versionName = "1.0.0"
+    }
+
+    packaging {
+        resources {
+            excludes += "/META-INF/{AL2.0,LGPL2.1}"
+        }
+    }
+
+    buildFeatures {
+        buildConfig = true
+    }
+
+    buildTypes {
+        // >>> cmp:feature firebase
+        getByName("debug") {
+            // Debug builds point GitLive Firebase at the local emulators (see Application/KoinHelper).
+            // 10.0.2.2 is the Android emulator's host-loopback alias.
+            buildConfigField("boolean", "USE_FIREBASE_EMULATORS", "true")
+            buildConfigField("String", "FIREBASE_EMULATOR_HOST", "\"10.0.2.2\"")
+            buildConfigField("int", "FIREBASE_AUTH_PORT", "9099")
+            buildConfigField("int", "FIREBASE_FIRESTORE_PORT", "8080")
+            buildConfigField("int", "FIREBASE_FUNCTIONS_PORT", "5001")
+            buildConfigField("int", "FIREBASE_STORAGE_PORT", "9199")
+            manifestPlaceholders["usesCleartextTraffic"] = "true"
+        }
+        getByName("release") {
+            isMinifyEnabled = true
+            isShrinkResources = true
+            buildConfigField("boolean", "USE_FIREBASE_EMULATORS", "false")
+            manifestPlaceholders["usesCleartextTraffic"] = "false"
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+        // <<< cmp:feature firebase
+        // >>> cmp:feature !firebase
+        getByName("release") {
+            isMinifyEnabled = true
+            isShrinkResources = true
+            manifestPlaceholders["usesCleartextTraffic"] = "false"
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+        getByName("debug") {
+            manifestPlaceholders["usesCleartextTraffic"] = "true"
+        }
+        // <<< cmp:feature !firebase
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+        isCoreLibraryDesugaringEnabled = true
+    }
+}
+
+dependencies {
+    // >>> cmp:feature room
+    add("kspAndroid", libs.room.compiler)
+    // >>> cmp:feature ios
+    add("kspIosSimulatorArm64", libs.room.compiler)
+    add("kspIosX64", libs.room.compiler)
+    add("kspIosArm64", libs.room.compiler)
+    // <<< cmp:feature ios
+    // >>> cmp:feature dev-client
+    add("kspDesktop", libs.room.compiler)
+    // <<< cmp:feature dev-client
+    // <<< cmp:feature room
+    add("coreLibraryDesugaring", libs.android.desugar.jdk)
+}
+
+// Pin the generated resources accessor package so `__PACKAGE__.generated.resources.Res`
+// is stable regardless of the Gradle project name. The default would derive from
+// rootProject.name (slugified), which couples imports to the app-name token.
+compose.resources {
+    publicResClass = true
+    packageOfResClass = "__PACKAGE__.generated.resources"
+    generateResClass = ResourcesExtension.ResourceClassGeneration.Always
+}
+
+// >>> cmp:feature room
+room {
+    schemaDirectory("$projectDir/schemas")
+}
+// <<< cmp:feature room
+
+// >>> cmp:feature dev-client
+// Entry point for the desktop dev-client window (and the class Compose Hot Reload launches).
+compose.desktop {
+    application {
+        mainClass = "__PACKAGE__.MainKt"
+    }
+}
+// <<< cmp:feature dev-client

package/template/composeApp/google-services.json

@@ -0,0 +1,29 @@
+{
+  "project_info": {
+    "project_number": "000000000000",
+    "project_id": "REPLACE_ME_PROJECT_ID",
+    "storage_bucket": "REPLACE_ME_PROJECT_ID.appspot.com"
+  },
+  "client": [
+    {
+      "client_info": {
+        "mobilesdk_app_id": "1:000000000000:android:0000000000000000000000",
+        "android_client_info": {
+          "package_name": "__PACKAGE__"
+        }
+      },
+      "oauth_client": [],
+      "api_key": [
+        {
+          "current_key": "REPLACE_ME_ANDROID_API_KEY"
+        }
+      ],
+      "services": {
+        "appinvite_service": {
+          "other_platform_oauth_client": []
+        }
+      }
+    }
+  ],
+  "configuration_version": "1"
+}

package/template/composeApp/proguard-rules.pro

@@ -0,0 +1,34 @@
+# Kotlin Serialization
+-keepattributes *Annotation*, InnerClasses
+-dontnote kotlinx.serialization.AnnotationsKt
+-keepclassmembers class kotlinx.serialization.json.** { *** Companion; }
+-keepclasseswithmembers class kotlinx.serialization.json.** { kotlinx.serialization.KSerializer serializer(...); }
+-keep,includedescriptorclasses class __PACKAGE__.**$$serializer { *; }
+-keepclassmembers class __PACKAGE__.** {
+    *** Companion;
+}
+-keepclasseswithmembers class __PACKAGE__.** {
+    kotlinx.serialization.KSerializer serializer(...);
+}
+
+# Koin
+-keep class org.koin.** { *; }
+-keepnames class org.koin.**
+
+# Firebase
+-keep class com.google.firebase.** { *; }
+-keep class dev.gitlive.firebase.** { *; }
+-dontwarn com.google.firebase.**
+
+# Coroutines
+-keepnames class kotlinx.coroutines.internal.MainDispatcherFactory {}
+-keepnames class kotlinx.coroutines.CoroutineExceptionHandler {}
+
+# Coil
+-dontwarn okio.**
+
+# Navigation
+-keepnames class androidx.navigation.**
+
+# Compose
+-keep class androidx.compose.** { *; }

package/template/composeApp/src/androidDebug/AndroidManifest.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- >>> cmp:feature inspector -->
+    <!-- The debug inspector server needs socket permission even if a future template fork
+         drops INTERNET from the main manifest; loopback-only bind, never on the LAN. -->
+    <uses-permission android:name="android.permission.INTERNET" />
+    <!-- <<< cmp:feature inspector -->
+
+    <application
+        android:networkSecurityConfig="@xml/debug_network_security_config"
+        android:usesCleartextTraffic="true" />
+</manifest>

package/template/composeApp/src/androidDebug/kotlin/com/example/app/inspector/ComposeRootRegistry.kt

@@ -0,0 +1,40 @@
+package __PACKAGE__.inspector
+
+import android.annotation.SuppressLint
+import androidx.compose.ui.platform.ViewRootForTest
+import java.lang.ref.WeakReference
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * Debug-only registry of live Compose roots, discovered via the public
+ * [ViewRootForTest.Companion.onViewCreatedCallback] hook — the same mechanism the Compose
+ * test framework uses. Installed from [startInspector] in Application.onCreate, BEFORE any
+ * Activity exists, so every root (including dialogs/popups, each its own AndroidComposeView)
+ * is captured.
+ *
+ * `@SuppressLint("VisibleForTests")`: ViewRootForTest is public API carrying a lint-severity
+ * `@VisibleForTesting` annotation — debug-only usage is precisely its spirit. This class never
+ * ships in release (the whole `inspector` package exists only in the androidDebug source set).
+ */
+@SuppressLint("VisibleForTests")
+object ComposeRootRegistry {
+
+    private val roots = CopyOnWriteArrayList<WeakReference<ViewRootForTest>>()
+
+    /** Install the root-discovery callback. Must run before the first Activity's setContent. */
+    fun install() {
+        ViewRootForTest.onViewCreatedCallback = { root ->
+            roots.removeAll { it.get() == null }
+            roots += WeakReference(root)
+        }
+    }
+
+    /**
+     * The topmost live root: attached to a window, preferring the one with window focus
+     * (so an open dialog/popup wins over the screen beneath it).
+     */
+    fun current(): ViewRootForTest? {
+        val live = roots.mapNotNull { it.get() }.filter { it.view.isAttachedToWindow }
+        return live.lastOrNull { it.view.hasWindowFocus() } ?: live.lastOrNull()
+    }
+}

package/template/composeApp/src/androidDebug/kotlin/com/example/app/inspector/InspectorCatalog.kt

@@ -0,0 +1,80 @@
+package __PACKAGE__.inspector
+
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.unit.Dp
+import __PACKAGE__.presentation.theme.__THEME_PREFIX__Colors
+import __PACKAGE__.presentation.theme.__THEME_PREFIX__Tokens
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.put
+
+/**
+ * The declared design-system catalog, served on GET /inspect/design-system in the shape the
+ * cmp-inspector MCP consumes: `{ "colors": {name: "#RRGGBB"}, "dimens": {name: "16dp"} }`.
+ *
+ * Hand-registry by design (no kotlin-reflect, no codegen): values are read from the REAL
+ * `__THEME_PREFIX__Colors` / `__THEME_PREFIX__Tokens` objects — never string-literal
+ * duplicates — so renaming a token breaks this file at compile time. If you ADD a token to
+ * the theme, add it here too (`create-cmp doctor` warns when a declared token is missing).
+ */
+object InspectorCatalog {
+
+    private val prettyJson = Json { prettyPrint = true }
+
+    fun json(): String {
+        val doc = buildJsonObject {
+            put("colors", buildJsonObject {
+                put("Primary", __THEME_PREFIX__Colors.Primary.toHex())
+                put("OnPrimary", __THEME_PREFIX__Colors.OnPrimary.toHex())
+                put("Accent", __THEME_PREFIX__Colors.Accent.toHex())
+                put("OnAccent", __THEME_PREFIX__Colors.OnAccent.toHex())
+                put("Secondary", __THEME_PREFIX__Colors.Secondary.toHex())
+                put("Error", __THEME_PREFIX__Colors.Error.toHex())
+                put("Success", __THEME_PREFIX__Colors.Success.toHex())
+                put("Warning", __THEME_PREFIX__Colors.Warning.toHex())
+                put("Info", __THEME_PREFIX__Colors.Info.toHex())
+                put("Background", __THEME_PREFIX__Colors.Background.toHex())
+                put("Surface", __THEME_PREFIX__Colors.Surface.toHex())
+                put("SurfaceVariant", __THEME_PREFIX__Colors.SurfaceVariant.toHex())
+                put("OnSurface", __THEME_PREFIX__Colors.OnSurface.toHex())
+                put("OnSurfaceVariant", __THEME_PREFIX__Colors.OnSurfaceVariant.toHex())
+                put("Outline", __THEME_PREFIX__Colors.Outline.toHex())
+                put("OutlineVariant", __THEME_PREFIX__Colors.OutlineVariant.toHex())
+                put("Divider", __THEME_PREFIX__Colors.Divider.toHex())
+            })
+            put("dimens", buildJsonObject {
+                put("ElevationCard", __THEME_PREFIX__Tokens.ElevationCard.token())
+                put("ElevationModal", __THEME_PREFIX__Tokens.ElevationModal.token())
+                put("PaddingPage", __THEME_PREFIX__Tokens.PaddingPage.token())
+                put("PaddingCard", __THEME_PREFIX__Tokens.PaddingCard.token())
+                put("GapCard", __THEME_PREFIX__Tokens.GapCard.token())
+                put("BottomNavHeight", __THEME_PREFIX__Tokens.BottomNavHeight.token())
+                put("RadiusCard", __THEME_PREFIX__Tokens.RadiusCard.token())
+                put("RadiusPill", __THEME_PREFIX__Tokens.RadiusPill.token())
+                put("RadiusModal", __THEME_PREFIX__Tokens.RadiusModal.token())
+                put("RadiusInput", __THEME_PREFIX__Tokens.RadiusInput.token())
+            })
+        }
+        return prettyJson.encodeToString(JsonElement.serializer(), doc)
+    }
+
+    /** "#RRGGBB" for fully-opaque colours (the catalog convention), "#AARRGGBB" otherwise. */
+    private fun Color.toHex(): String {
+        val argb = toArgb()
+        val alpha = (argb ushr 24) and 0xFF
+        return if (alpha == 0xFF) {
+            "#%06X".format(argb and 0xFFFFFF)
+        } else {
+            "#%08X".format(argb)
+        }
+    }
+
+    /** "16dp" (integer dp values render without the decimal point). */
+    private fun Dp.token(): String {
+        val v = value
+        return if (v == v.toInt().toFloat()) "${v.toInt()}dp" else "${v}dp"
+    }
+}