biucingcli 0.9.1__py3-none-any.whl

biucingcli/template_data/android/template/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*.{kt,kts}]
+charset = utf-8
+end_of_line = lf
+indent_style = space
+indent_size = 4
+insert_final_newline = true
+ktlint_code_style = ktlint_official

biucingcli/template_data/android/template/.gitignore

@@ -0,0 +1,26 @@
+.gradle/
+.idea/
+build/
+local.properties
+captures/
+*.iml
+app/build/
+core/**/build/
+feature/**/build/
+
+# Local credentials and signing material
+.env
+.env.*
+!.env.example
+/credentials/
+/signing/
+*.p8
+*.p12
+*.pfx
+*.jks
+*.keystore
+/key.properties
+/keystore.properties
+/signing.properties
+/fastlane/*.json
+/play-store-service-account.json

biucingcli/template_data/android/template/.mise.toml

@@ -0,0 +1,3 @@
+[tools]
+java = "{{JAVA_VERSION}}"
+ruby = "3.3.4"

biucingcli/template_data/android/template/Brewfile

@@ -0,0 +1,6 @@
+brew "mise"
+cask "android-platform-tools"
+brew "openjdk@{{JAVA_VERSION}}"
+brew "fastlane"
+brew "gh"
+brew "jq"

biucingcli/template_data/android/template/Makefile

@@ -0,0 +1,103 @@
+SHELL := /bin/zsh
+
+APP_NAME={{PROJECT_NAME}}
+WORKTREE_ROOT ?= $(shell git rev-parse --show-toplevel 2>/dev/null || pwd)
+WORKTREE_LABEL ?= $(shell basename "$(WORKTREE_ROOT)" | tr '[:upper:]' '[:lower:]' | tr -cs 'a-z0-9' '-' | sed 's/^-//; s/-$$//')
+WORKTREE_ID ?= w$(shell printf '%s' "$(WORKTREE_ROOT)" | shasum | cut -c1-8)
+WORKTREE_SLUG ?= $(APP_NAME)-$(WORKTREE_ID)
+GRADLE_USER_HOME ?= $(WORKTREE_ROOT)/.gradle/worktree/$(WORKTREE_ID)
+GRADLE_PROJECT_CACHE ?= $(WORKTREE_ROOT)/.gradle
+ANDROID_LOCAL_PROPERTIES ?= $(WORKTREE_ROOT)/local.properties
+DEBUG_APPLICATION_ID_SUFFIX ?= .debug.$(WORKTREE_ID)
+EFFECTIVE_DEBUG_APPLICATION_ID ?= {{APPLICATION_ID}}$(DEBUG_APPLICATION_ID_SUFFIX)
+GRADLE := GRADLE_USER_HOME=$(GRADLE_USER_HOME) ./gradlew -Dorg.gradle.project.biucing.worktree.applicationIdSuffix=$(DEBUG_APPLICATION_ID_SUFFIX)
+
+export GRADLE_USER_HOME
+
+.PHONY: bootstrap doctor wrapper verify-supply-chain clean build bundle-release artifact-info verify-release-artifact verify verify-release-signing test test-ui lint format install-debug release-doctor archive beta release worktree-info worktree-doctor clean-worktree help
+
+bootstrap:
+	./scripts/bootstrap
+
+doctor:
+	./scripts/doctor
+
+wrapper:
+	./scripts/sync-gradle-wrapper
+
+verify-supply-chain:
+	./scripts/verify-gradle-supply-chain
+
+clean build bundle-release verify-release-signing test test-ui lint format install-debug: verify-supply-chain
+
+clean:
+	$(GRADLE) clean
+
+build:
+	$(GRADLE) assembleDebug
+
+bundle-release:
+	$(GRADLE) bundleRelease
+
+artifact-info:
+	./scripts/artifact-info
+
+verify-release-artifact:
+	./scripts/verify-release-artifact
+
+verify: verify-supply-chain doctor lint test build
+
+verify-release-signing:
+	$(GRADLE) :app:verifyReleaseSigning
+
+test:
+	$(GRADLE) test
+
+test-ui:
+	$(GRADLE) connectedDebugAndroidTest
+
+lint:
+	$(GRADLE) lint
+
+format:
+	$(GRADLE) spotlessApply
+
+install-debug:
+	$(GRADLE) installDebug
+
+release-doctor:
+	fastlane release_doctor
+
+archive:
+	fastlane archive
+
+beta:
+	fastlane beta
+
+release:
+	fastlane release
+
+worktree-info:
+	@printf '%s\n' "Project: {{PROJECT_NAME}}"
+	@printf '%s\n' "Worktree root: $(WORKTREE_ROOT)"
+	@printf '%s\n' "WORKTREE_LABEL: $(WORKTREE_LABEL)"
+	@printf '%s\n' "WORKTREE_ID: $(WORKTREE_ID)"
+	@printf '%s\n' "WORKTREE_SLUG: $(WORKTREE_SLUG)"
+	@printf '%s\n' "Gradle user home: $(GRADLE_USER_HOME)"
+	@printf '%s\n' "Gradle project cache: $(GRADLE_PROJECT_CACHE)"
+	@printf '%s\n' "local.properties: $(ANDROID_LOCAL_PROPERTIES)"
+	@printf '%s\n' "Debug application ID suffix: $(DEBUG_APPLICATION_ID_SUFFIX)"
+	@printf '%s\n' "Debug application ID: $(EFFECTIVE_DEBUG_APPLICATION_ID)"
+
+worktree-doctor:
+	@printf '%s\n' "Checking Android worktree isolation..."
+	@test -n "$(WORKTREE_ID)" || (printf '%s\n' "WORKTREE_ID is empty" && exit 1)
+	@case "$(GRADLE_USER_HOME)" in "$(WORKTREE_ROOT)"/*) ;; *) printf '%s\n' "Gradle user home should stay inside this worktree: $(GRADLE_USER_HOME)"; exit 1;; esac
+	@if [ -f "$(ANDROID_LOCAL_PROPERTIES)" ]; then printf '%s\n' "local.properties is local to this worktree and must remain untracked."; else printf '%s\n' "local.properties is absent; run make bootstrap or configure Android SDK paths if needed."; fi
+	@printf '%s\n' "Android worktree isolation looks ready."
+
+clean-worktree:
+	rm -rf "$(GRADLE_USER_HOME)" app/build core/*/build feature/*/build build
+
+help:
+	@printf '%s\n' "Common commands:" "  make bootstrap  Prepare project dependencies and tooling" "  make doctor     Check the local environment" "  make lint       Run static checks" "  make test       Run automated tests" "  make verify     Run the template quality gate" "  make build      Build the project" "  make clean      Remove generated build state" "  make help       Show this command contract"

biucingcli/template_data/android/template/README.md

@@ -0,0 +1,163 @@
+# {{DISPLAY_NAME}}
+
+This project was generated by BiucingCLI as a Kotlin Android starter for a mid-sized team.
+
+## Stack
+
+- Kotlin
+- Android Gradle Plugin
+- Gradle Wrapper
+- Jetpack Compose
+- fastlane
+
+## Configuration
+
+- Application ID: `{{APPLICATION_ID}}`
+- Namespace: `{{ANDROID_NAMESPACE}}`
+- Compile SDK: `{{COMPILE_SDK}}`
+- Minimum SDK: `{{MIN_SDK}}`
+- Target SDK: `{{TARGET_SDK}}`
+- Java version: `{{JAVA_VERSION}}`
+
+## Repository Layout
+
+- `app/`: installable Android application module
+- `feature/`: user-facing feature modules such as `home` and `settings`
+- `core/`: shared modules such as models, design system, network config, and test support
+  `core/designsystem` now includes starter theme tokens, dark mode colors, and reusable Compose section components
+- `gradle/`: version catalog and wrapper configuration
+- `fastlane/`: beta and release automation
+- `scripts/`: bootstrap and environment checks
+
+## Getting Started
+
+```bash
+make bootstrap
+make doctor
+make format
+make build
+make test
+make verify
+```
+
+## Worktree Workflow
+
+Each worktree derives a human-readable `WORKTREE_LABEL` from its directory name
+and a hash-based `WORKTREE_ID` from the worktree root path, prefixed with `w`
+so generated Android application ID suffixes remain valid. Override
+`WORKTREE_ID` when you want a shorter or stable value across renamed folders:
+
+```bash
+WORKTREE_ID=feature-a make worktree-info
+WORKTREE_ID=feature-a make build
+WORKTREE_ID=feature-a make install-debug
+WORKTREE_ID=feature-a make clean-worktree
+```
+
+`make worktree-info` prints the isolated Gradle user home, project cache,
+`local.properties`, and debug application ID. Debug builds receive
+`DEBUG_APPLICATION_ID_SUFFIX` through Gradle, so parallel worktrees can install
+side by side on the same emulator or device. Set `DEBUG_APPLICATION_ID_SUFFIX=.debug`
+to keep the classic single debug package name.
+
+If the team later upgrades Gradle and needs to refresh the wrapper files, run:
+
+```bash
+make wrapper
+```
+
+Then regenerate `gradle/verification-metadata.xml` with Gradle's dependency-verification workflow, review every new checksum, and commit the updated wrapper and verification files together. The template pins the Gradle distribution SHA-256 and the official wrapper JAR SHA-256; `make verify-supply-chain` rejects a changed URL, checksum, dynamic version, or incomplete dependency metadata.
+
+## Standard Commands
+
+```bash
+make bootstrap
+make doctor
+make verify-supply-chain
+make format
+make build
+./gradlew assembleRelease
+make test
+make test-ui
+make lint
+make verify
+make install-debug
+make verify-release-signing
+make release-doctor
+make archive
+make artifact-info
+make verify-release-artifact
+make beta
+make release
+make clean
+make help
+```
+
+`make doctor` validates the active JDK, Android SDK root, `cmdline-tools/latest`, `adb`, emulator/AVD visibility, and the committed Gradle supply-chain controls before you spend time on builds.
+`make test-ui` runs `connectedDebugAndroidTest`, so boot an emulator or connect a device first. AVDs created through Android Studio Device Manager work well for the generated Compose smoke test.
+If `adb devices` reports `unauthorized`, accept the host key prompt on the emulator or restart adb before re-running `make test-ui`.
+
+## Release Setup
+
+The generated starter treats build types like this:
+
+- `debug`: default local development build, with a `.debug` application ID suffix and `-debug` version suffix
+- `release`: production-shaped build intended for CI, beta handoff, or store preparation
+
+Release signing is optional for local generation and verification. If signing inputs are missing, `assembleRelease` still gives you an unsigned release artifact that is useful for smoke validation. Store delivery uses a signed Android App Bundle (AAB) built by `bundleRelease`.
+
+To wire real signing, choose one of these paths:
+
+1. Copy the keys from `docs/release-signing.properties.example` into `local.properties`
+2. Export `BIUCING_RELEASE_STORE_FILE`, `BIUCING_RELEASE_STORE_PASSWORD`, `BIUCING_RELEASE_KEY_ALIAS`, and `BIUCING_RELEASE_KEY_PASSWORD` in CI or your shell
+
+The Gradle template also accepts the same values as Gradle properties:
+
+- `biucing.release.storeFile`
+- `biucing.release.storePassword`
+- `biucing.release.keyAlias`
+- `biucing.release.keyPassword`
+
+For direct Gradle invocations, put these values in the user-level `~/.gradle/gradle.properties`, not the tracked project-level `gradle.properties`. The fastlane delivery lanes use `local.properties` or `BIUCING_RELEASE_*` so `make release-doctor`, `make archive`, `make beta`, and `make release` can verify the signing material before building.
+
+Before a real Google Play handoff, the team also needs to supply:
+
+- a Google Play Console app record for `{{APPLICATION_ID}}`
+- a Google Cloud service-account JSON key that is invited to the Play Console app
+- an upload keystore and all four signing values above
+
+Copy `fastlane/.env.example` to `fastlane/.env`, place the service-account JSON under the ignored `credentials/` directory and the upload keystore under the ignored `signing/` directory, then replace the placeholders. See `docs/release-delivery.md` for the complete setup path.
+
+`make verify` is the default local quality gate: it verifies the Gradle distribution, wrapper JAR, dependency checksums, then runs doctor, lint, unit tests, and a debug build. `gradle/verification-metadata.xml` enables strict checksum verification for downloaded plugins and dependencies.
+
+`make verify-release-signing` opens the configured keystore and verifies that the configured alias is a usable private-key entry without printing any signing secret.
+
+`make release-doctor` checks the service-account JSON path, release-signing inputs, upload keystore, private key, and enabled metadata configuration before a native bundle spends time building.
+
+`make archive` runs lint, unit tests, signing-input verification, and `bundleRelease`, then cryptographically verifies every AAB JAR signature and compares its signer SHA-256 fingerprint with the configured upload-key certificate before printing the artifact checksum. A mismatch fails before any Play upload.
+
+`make beta` runs the archive lane and uploads the AAB to the Google Play `internal` track by default.
+
+`make release` runs the archive lane and uploads the AAB to the Google Play `production` track as a `draft` by default. It does not make the release public; complete the Play Console review and required compliance information before promoting the draft.
+
+## Notes
+
+- `settings.gradle.kts` defines the module graph.
+- `gradle/libs.versions.toml` is the source of truth for plugin and dependency versions.
+- `.editorconfig` defines the baseline formatting behavior shared by Kotlin and Gradle Kotlin DSL files.
+- `make doctor` is the fastest way to catch missing SDK, JDK, or emulator setup before `make build` and `make test`.
+- `app/src/androidTest/` contains a starter Compose UI smoke test for the generated home screen.
+- `core/network` centralizes starter environment metadata that multiple features can share.
+- `core/testing` gives app and feature tests a shared fake environment provider.
+- `core/designsystem` now holds starter color tokens, spacing tokens, dark theme colors, and reusable Compose UI primitives such as section cards and status badges.
+- `app/` should stay focused on app shell concerns.
+- `feature/home` and `feature/settings` demonstrate how the template can scale past a single screen.
+- The starter design system is intentionally small, but it is structured so teams can grow tokens and reusable components without rewriting the first screens.
+- Dark mode is part of the starter theme contract, so new components should prefer `MaterialTheme.colorScheme` and shared tokens over hard-coded colors.
+- `gradle/wrapper/gradle-wrapper.jar` is committed in the starter and should stay versioned in the repo.
+- `gradle/wrapper/gradle-wrapper.jar.sha256`, `distributionSha256Sum`, and `gradle/verification-metadata.xml` are reviewable supply-chain inputs; never regenerate or accept checksum changes blindly.
+- `docs/release-signing.properties.example` documents the expected signing keys without committing secrets.
+- `.gitignore` protects the recommended `credentials/` and `signing/` directories, keystores, local signing property files, and Fastlane credential JSON. It cannot protect files already tracked or force-added.
+- `fastlane/Fastfile` owns Google Play credential checks, signed AAB creation, internal-track delivery, and draft production delivery.
+- `scripts/verify-release-artifact` verifies AAB archive structure, its JAR signature, and the exact upload certificate; `scripts/artifact-info` records the verified artifact checksum.
+- Google Play store listings can be managed from `fastlane/metadata/android` after `fastlane supply init`; Data safety, content ratings, policy declarations, and review answers remain Play Console responsibilities.

biucingcli/template_data/android/template/app/build.gradle.kts

@@ -0,0 +1,178 @@
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.kotlin.compose)
+}
+
+import java.util.Properties
+import java.security.KeyStore
+
+fun loadLocalProperties(rootDir: java.io.File): Properties {
+    val properties = Properties()
+    val localPropertiesFile = rootDir.resolve("local.properties")
+
+    if (localPropertiesFile.isFile) {
+        localPropertiesFile.inputStream().use(properties::load)
+    }
+
+    return properties
+}
+
+fun Project.releaseProperty(
+    localProperties: Properties,
+    gradleKey: String,
+    envKey: String,
+): String? {
+    return providers.gradleProperty(gradleKey).orNull
+        ?: System.getenv(envKey)
+        ?: localProperties.getProperty(gradleKey)
+}
+
+val localProperties = loadLocalProperties(rootDir)
+val releaseStoreFile = project.releaseProperty(
+    localProperties,
+    "biucing.release.storeFile",
+    "BIUCING_RELEASE_STORE_FILE",
+)
+val releaseStorePassword = project.releaseProperty(
+    localProperties,
+    "biucing.release.storePassword",
+    "BIUCING_RELEASE_STORE_PASSWORD",
+)
+val releaseKeyAlias = project.releaseProperty(
+    localProperties,
+    "biucing.release.keyAlias",
+    "BIUCING_RELEASE_KEY_ALIAS",
+)
+val releaseKeyPassword = project.releaseProperty(
+    localProperties,
+    "biucing.release.keyPassword",
+    "BIUCING_RELEASE_KEY_PASSWORD",
+)
+val hasCompleteReleaseSigning =
+    listOf(
+        releaseStoreFile,
+        releaseStorePassword,
+        releaseKeyAlias,
+        releaseKeyPassword,
+    ).all { !it.isNullOrBlank() }
+val debugApplicationIdSuffix =
+    providers.gradleProperty("biucing.worktree.applicationIdSuffix")
+        .orElse(providers.environmentVariable("BIUCING_ANDROID_APPLICATION_ID_SUFFIX"))
+        .orElse(".debug")
+        .get()
+
+android {
+    namespace = "{{ANDROID_NAMESPACE}}"
+    compileSdk = {{COMPILE_SDK}}
+
+    defaultConfig {
+        applicationId = "{{APPLICATION_ID}}"
+        minSdk = {{MIN_SDK}}
+        targetSdk = {{TARGET_SDK}}
+        versionCode = {{VERSION_CODE}}
+        versionName = "{{VERSION_NAME}}"
+
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        vectorDrawables {
+            useSupportLibrary = true
+        }
+    }
+
+    signingConfigs {
+        create("release") {
+            if (hasCompleteReleaseSigning) {
+                storeFile = rootProject.file(releaseStoreFile!!)
+                storePassword = releaseStorePassword
+                keyAlias = releaseKeyAlias
+                keyPassword = releaseKeyPassword
+            }
+        }
+    }
+
+    buildTypes {
+        debug {
+            applicationIdSuffix = debugApplicationIdSuffix
+            versionNameSuffix = "-debug"
+        }
+
+        release {
+            isMinifyEnabled = false
+            if (hasCompleteReleaseSigning) {
+                signingConfig = signingConfigs.getByName("release")
+            }
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.toVersion("{{JAVA_VERSION}}")
+        targetCompatibility = JavaVersion.toVersion("{{JAVA_VERSION}}")
+    }
+
+    kotlinOptions {
+        jvmTarget = "{{JAVA_VERSION}}"
+    }
+
+    buildFeatures {
+        compose = true
+    }
+}
+
+tasks.register("verifyReleaseSigning") {
+    group = "verification"
+    description = "Verifies that the configured release keystore contains the configured private key."
+
+    doLast {
+        require(hasCompleteReleaseSigning) {
+            "Configure all biucing.release.* values or BIUCING_RELEASE_* environment variables."
+        }
+
+        val storeFile = rootProject.file(requireNotNull(releaseStoreFile))
+        require(storeFile.isFile) { "Release keystore does not exist: ${storeFile.path}" }
+
+        val storePassword = requireNotNull(releaseStorePassword)
+        val keyAlias = requireNotNull(releaseKeyAlias)
+        val keyPassword = requireNotNull(releaseKeyPassword)
+        val keyStore = KeyStore.getInstance(KeyStore.getDefaultType())
+
+        storeFile.inputStream().use { keyStore.load(it, storePassword.toCharArray()) }
+        require(keyStore.containsAlias(keyAlias)) {
+            "Release keystore does not contain alias: $keyAlias"
+        }
+        require(keyStore.isKeyEntry(keyAlias)) {
+            "Release signing alias is not a private-key entry: $keyAlias"
+        }
+        requireNotNull(keyStore.getKey(keyAlias, keyPassword.toCharArray())) {
+            "Release signing key could not be opened for alias: $keyAlias"
+        }
+    }
+}
+
+dependencies {
+    implementation(project(":core:model"))
+    implementation(project(":core:designsystem"))
+    implementation(project(":core:network"))
+    implementation(project(":feature:home"))
+    implementation(project(":feature:settings"))
+
+    implementation(platform(libs.androidx.compose.bom))
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.lifecycle.runtime.ktx)
+    implementation(libs.androidx.activity.compose)
+    implementation(libs.androidx.compose.ui)
+    implementation(libs.androidx.compose.ui.tooling.preview)
+    implementation(libs.androidx.compose.material3)
+    implementation(libs.google.material)
+
+    testImplementation(libs.junit4)
+    testImplementation(project(":core:testing"))
+    androidTestImplementation(platform(libs.androidx.compose.bom))
+    androidTestImplementation(libs.androidx.test.ext.junit)
+    androidTestImplementation(libs.androidx.espresso.core)
+    androidTestImplementation(libs.androidx.compose.ui.test.junit4)
+    debugImplementation(libs.androidx.compose.ui.test.manifest)
+}

biucingcli/template_data/android/template/app/proguard-rules.pro

@@ -0,0 +1 @@
+# Intentionally minimal for the starter template.

biucingcli/template_data/android/template/app/src/androidTest/java/app/HomeRouteUiTest.kt

@@ -0,0 +1,21 @@
+package {{PACKAGE_NAME}}
+
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class HomeRouteUiTest {
+    @get:Rule
+    val composeRule = createAndroidComposeRule<MainActivity>()
+
+    @Test
+    fun homeScreenShowsGeneratedGreeting() {
+        composeRule.onNodeWithText("{{DISPLAY_NAME}}", substring = true).assertIsDisplayed()
+        composeRule.onNodeWithText("Generated by BiucingCLI", substring = true).assertIsDisplayed()
+    }
+}

biucingcli/template_data/android/template/app/src/main/AndroidManifest.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application
+        android:allowBackup="true"
+        android:label="{{DISPLAY_NAME}}"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.{{KOTLIN_MODULE_NAME}}">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>

biucingcli/template_data/android/template/app/src/main/java/app/MainActivity.kt

@@ -0,0 +1,36 @@
+package {{PACKAGE_NAME}}
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Surface
+import androidx.compose.ui.Modifier
+import {{PACKAGE_NAME}}.core.designsystem.BiucingSpacing
+import {{PACKAGE_NAME}}.core.designsystem.BiucingTheme
+import {{PACKAGE_NAME}}.feature.home.HomeRoute
+import {{PACKAGE_NAME}}.feature.settings.SettingsRoute
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            BiucingTheme {
+                Surface {
+                    Column(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .padding(BiucingSpacing.large),
+                        verticalArrangement = Arrangement.spacedBy(BiucingSpacing.large),
+                    ) {
+                        HomeRoute()
+                        SettingsRoute()
+                    }
+                }
+            }
+        }
+    }
+}

biucingcli/template_data/android/template/app/src/main/res/values/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">{{DISPLAY_NAME}}</string>
+</resources>

biucingcli/template_data/android/template/app/src/main/res/values/themes.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:tools="http://schemas.android.com/tools">
+    <style name="Theme.{{KOTLIN_MODULE_NAME}}" parent="Theme.Material3.DayNight">
+        <item name="android:statusBarColor">@android:color/transparent</item>
+        <item name="android:navigationBarColor">@android:color/black</item>
+        <item name="android:windowLightStatusBar" tools:targetApi="23">true</item>
+    </style>
+</resources>

biucingcli/template_data/android/template/app/src/test/java/app/AppSmokeTest.kt

@@ -0,0 +1,19 @@
+package {{PACKAGE_NAME}}
+
+import {{PACKAGE_NAME}}.core.testing.FakeAppEnvironmentProvider
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class AppSmokeTest {
+    @Test
+    fun projectNameIsStable() {
+        assertEquals("{{PROJECT_NAME}}", "{{PROJECT_NAME}}")
+    }
+
+    @Test
+    fun fakeEnvironmentProviderExposesPredictableReleaseChannel() {
+        val environment = FakeAppEnvironmentProvider().environment()
+
+        assertEquals("beta", environment.releaseChannel)
+    }
+}

biucingcli/template_data/android/template/build.gradle.kts

@@ -0,0 +1,27 @@
+import com.diffplug.gradle.spotless.SpotlessExtension
+
+plugins {
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.android.library) apply false
+    alias(libs.plugins.kotlin.android) apply false
+    alias(libs.plugins.kotlin.compose) apply false
+    alias(libs.plugins.spotless)
+}
+
+subprojects {
+    apply(plugin = "com.diffplug.spotless")
+
+    extensions.configure<SpotlessExtension> {
+        kotlin {
+            target("**/*.kt")
+            targetExclude("**/build/**/*.kt")
+            ktlint(libs.versions.ktlint.get())
+        }
+
+        kotlinGradle {
+            target("**/*.kts")
+            targetExclude("**/build/**/*.kts")
+            ktlint(libs.versions.ktlint.get())
+        }
+    }
+}

biucingcli/template_data/android/template/core/designsystem/build.gradle.kts

@@ -0,0 +1,33 @@
+plugins {
+    alias(libs.plugins.android.library)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.kotlin.compose)
+}
+
+android {
+    namespace = "{{PACKAGE_NAME}}.core.designsystem"
+    compileSdk = {{COMPILE_SDK}}
+
+    defaultConfig {
+        minSdk = {{MIN_SDK}}
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.toVersion("{{JAVA_VERSION}}")
+        targetCompatibility = JavaVersion.toVersion("{{JAVA_VERSION}}")
+    }
+
+    kotlinOptions {
+        jvmTarget = "{{JAVA_VERSION}}"
+    }
+
+    buildFeatures {
+        compose = true
+    }
+}
+
+dependencies {
+    implementation(platform(libs.androidx.compose.bom))
+    implementation(libs.androidx.compose.ui)
+    implementation(libs.androidx.compose.material3)
+}