@jetstart/cli 1.7.0 → 2.0.2

package/template/base/README.md

@@ -0,0 +1,34 @@
+# {{PROJECT_NAME}}
+
+A JetStart project with Kotlin and Jetpack Compose.
+
+## Getting Started
+
+```bash
+# Start development server
+jetstart dev
+
+# Build production APK
+jetstart build
+
+# View logs
+jetstart logs
+```
+
+## Project Structure
+
+```
+{{PROJECT_NAME}}/
+├── app/
+│   └── src/
+│       └── main/
+│           ├── java/          # Kotlin source files
+│           └── res/           # Resources
+├── jetstart.config.json       # JetStart configuration
+└── build.gradle               # Gradle build file
+```
+
+## Learn More
+
+- [JetStart Documentation](https://github.com/phantom/jetstart)
+- [Jetpack Compose](https://developer.android.com/jetpack/compose)

package/template/base/app/build.gradle

@@ -0,0 +1,80 @@
+plugins {
+    id 'com.android.application'
+    id 'org.jetbrains.kotlin.android'
+    id 'com.google.devtools.ksp'
+    id 'com.jetstart.hot-reload' version '1.0.0'  // True hot reload instrumentation
+    id 'org.jetbrains.kotlin.plugin.compose'
+}
+
+android {
+    namespace '{{PACKAGE_NAME}}'
+    compileSdk 34
+
+    defaultConfig {
+        applicationId "{{PACKAGE_NAME}}"
+        minSdk 24
+        targetSdk 34
+        versionCode 1
+        versionName "1.0.0"
+
+        // JetStart injected fields
+        buildConfigField "String", "JETSTART_SERVER_URL", "\"\"" // injected by: jetstart dev
+        buildConfigField "String", "JETSTART_SESSION_ID", "\"\"" // injected by: jetstart dev
+        // End JetStart fields
+    }
+
+    buildTypes {
+        debug {
+            debuggable true
+        }
+        release {
+            debuggable false
+            minifyEnabled true
+            shrinkResources true
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+            // Signing config is injected by `jetstart build --sign` via keystore.properties
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+
+    buildFeatures {
+        compose true
+        buildConfig true  // Required for JetStart hot reload
+    }
+
+
+}
+
+dependencies {
+    implementation 'androidx.core:core-ktx:1.12.0'
+    implementation 'androidx.appcompat:appcompat:1.6.1'
+    implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.6.2'
+    implementation 'androidx.activity:activity-compose:1.8.1'
+    implementation platform('androidx.compose:compose-bom:2023.10.01')
+    implementation 'androidx.compose.ui:ui'
+    implementation 'androidx.compose.ui:ui-graphics'
+    implementation 'androidx.compose.ui:ui-tooling-preview'
+    implementation 'androidx.compose.material3:material3'
+
+    // Room
+    implementation 'androidx.room:room-runtime:2.6.1'
+    implementation 'androidx.room:room-ktx:2.6.1'
+    ksp 'androidx.room:room-compiler:2.6.1'
+    
+    // Gson
+    implementation 'com.google.code.gson:gson:2.10.1'
+
+    // JetStart Hot Reload Runtime 
+    implementation 'com.jetstart:hot-reload-runtime:1.0.0'
+
+    implementation "androidx.lifecycle:lifecycle-viewmodel-compose:2.6.2"
+    
+}

package/template/base/app/proguard-rules.pro

@@ -0,0 +1,33 @@
+# JetStart default ProGuard/R8 rules
+# Add your project-specific rules at the bottom.
+# Kotlin
+-keep class kotlin.** { *; }
+-keepclassmembers class **$WhenMappings { <fields>; }
+-dontwarn kotlin.**
+# Jetpack Compose
+-keep class androidx.compose.** { *; }
+-keepclassmembers class androidx.compose.** { *; }
+-dontwarn androidx.compose.**
+# Room
+-keep class * extends androidx.room.RoomDatabase { *; }
+-keep @androidx.room.Entity class * { *; }
+-keep @androidx.room.Dao class * { *; }
+-dontwarn androidx.room.**
+# Gson (JSON serialization)
+-keepclassmembers class * {
+    @com.google.gson.annotations.SerializedName <fields>;
+}
+-keep class * implements com.google.gson.TypeAdapterFactory { *; }
+# OkHttp + WebSocket
+# Only used by HotReload (debug only). R8 strips the entire
+# HotReload code path in release builds via BuildConfig.DEBUG = false.
+-dontwarn okhttp3.**
+-dontwarn okio.**
+# DivKit
+-keep class com.yandex.div.** { *; }
+-dontwarn com.yandex.div.**
+# Enum names (required for serialization)
+-keepclassmembers enum * { *; }
+# App data classes used by Room
+-keep class {{PACKAGE_NAME}}.data.** { *; }
+# Add your own keep rules below this line

package/template/base/app/src/main/AndroidManifest.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
+
+    <application
+        android:allowBackup="true"
+        android:label="@string/app_name"
+        android:theme="@style/Theme.{{THEME_NAME}}"
+        android:networkSecurityConfig="@xml/network_security_config">
+        
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/provider_paths" />
+        </provider>
+
+        <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>

package/template/base/app/src/main/java/__PACKAGE_PATH__/MainActivity.kt

@@ -0,0 +1,64 @@
+package {{PACKAGE_NAME}}
+
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import {{PACKAGE_NAME}}.ui.NotesScreen
+import com.jetstart.hotreload.HotReload
+
+class MainActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // Hot reload is ONLY active in debug builds.
+        // In release builds this block is completely eliminated by R8 (BuildConfig.DEBUG = false).
+        if (BuildConfig.DEBUG) {
+            try {
+                val serverUrl = BuildConfig.JETSTART_SERVER_URL
+                val sessionId = BuildConfig.JETSTART_SESSION_ID
+                if (serverUrl.isNotEmpty()) {
+                    HotReload.connect(this, serverUrl, sessionId)
+                }
+            } catch (e: Exception) {
+                android.util.Log.w("MainActivity", "Hot reload not configured: ${e.message}")
+            }
+        }
+
+        setContent {
+            MaterialTheme {
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.background
+                ) {
+                    // Observe reload version - forces recomposition when DEX hot reload happens
+                    val reloadVersion by HotReload.reloadVersion.collectAsState()
+
+                    // Use reloadVersion as key to force recomposition of entire tree
+                    key(reloadVersion) {
+                        // Normal mode: render actual Compose code
+                        AppContent()
+                    }
+                }
+            }
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        if (BuildConfig.DEBUG) { HotReload.disconnect() }
+    }
+}
+
+/**
+ * Main App Content
+ */
+@Composable
+fun AppContent() {
+    NotesScreen()
+}

package/template/base/app/src/main/java/__PACKAGE_PATH__/data/AppDatabase.kt

@@ -0,0 +1,46 @@
+package {{PACKAGE_NAME}}.data
+
+import android.content.Context
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import androidx.room.TypeConverter
+import androidx.room.TypeConverters
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+
+@Database(entities = [Note::class], version = 1, exportSchema = false)
+@TypeConverters(Converters::class)
+abstract class AppDatabase : RoomDatabase() {
+    abstract fun noteDao(): NoteDao
+
+    companion object {
+        @Volatile
+        private var INSTANCE: AppDatabase? = null
+
+        fun getDatabase(context: Context): AppDatabase {
+            return INSTANCE ?: synchronized(this) {
+                val instance = Room.databaseBuilder(
+                    context.applicationContext,
+                    AppDatabase::class.java,
+                    "note_database"
+                ).build()
+                INSTANCE = instance
+                instance
+            }
+        }
+    }
+}
+
+class Converters {
+    @TypeConverter
+    fun fromString(value: String): List<String> {
+        val listType = object : TypeToken<List<String>>() {}.type
+        return Gson().fromJson(value, listType)
+    }
+
+    @TypeConverter
+    fun fromList(list: List<String>): String {
+        return Gson().toJson(list)
+    }
+}

package/template/base/app/src/main/java/__PACKAGE_PATH__/data/Note.kt

@@ -0,0 +1,12 @@
+package {{PACKAGE_NAME}}.data
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+@Entity(tableName = "notes")
+data class Note(
+    @PrimaryKey(autoGenerate = true) val id: Int = 0,
+    val content: String,
+    val tags: List<String>,
+    val timestamp: Long = System.currentTimeMillis()
+)

package/template/base/app/src/main/java/__PACKAGE_PATH__/data/NoteDao.kt

@@ -0,0 +1,23 @@
+package {{PACKAGE_NAME}}.data
+
+import androidx.room.Dao
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface NoteDao {
+    @Query("SELECT * FROM notes ORDER BY timestamp DESC")
+    fun getAllNotes(): Flow<List<Note>>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertNote(note: Note)
+
+    @Delete
+    suspend fun deleteNote(note: Note)
+    
+    @Query("SELECT * FROM notes WHERE content LIKE '%' || :query || '%'")
+    fun searchNotes(query: String): Flow<List<Note>>
+}

package/template/base/app/src/main/java/__PACKAGE_PATH__/logic/TaggingEngine.kt

@@ -0,0 +1,26 @@
+package {{PACKAGE_NAME}}.logic
+
+class TaggingEngine {
+    fun autoTag(content: String): List<String> {
+        val tags = mutableListOf<String>()
+        val lowerContent = content.lowercase()
+        
+        if (lowerContent.contains("work") || lowerContent.contains("meeting") || lowerContent.contains("job")) {
+            tags.add("work")
+        }
+        if (lowerContent.contains("idea") || lowerContent.contains("concept") || lowerContent.contains("think")) {
+            tags.add("idea")
+        }
+        if (lowerContent.contains("money") || lowerContent.contains("cost") || lowerContent.contains("price") || lowerContent.contains("$") || lowerContent.contains("€")) {
+            tags.add("money")
+        }
+        if (lowerContent.contains("bug") || lowerContent.contains("fix") || lowerContent.contains("error") || lowerContent.contains("crash")) {
+            tags.add("bug")
+        }
+        if (lowerContent.contains("todo") || lowerContent.contains("must") || lowerContent.contains("should")) {
+            tags.add("todo")
+        }
+        
+        return tags
+    }
+}

package/template/base/app/src/main/java/__PACKAGE_PATH__/ui/NotesScreen.kt

@@ -0,0 +1,185 @@
+package {{PACKAGE_NAME}}.ui
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.staggeredgrid.LazyVerticalStaggeredGrid
+import androidx.compose.foundation.lazy.staggeredgrid.StaggeredGridCells
+import androidx.compose.foundation.lazy.staggeredgrid.items
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import androidx.lifecycle.viewmodel.compose.viewModel
+import {{PACKAGE_NAME}}.data.Note
+import java.text.SimpleDateFormat
+import java.util.*
+
+import androidx.compose.ui.graphics.Color
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun NotesScreen(viewModel: NotesViewModel = viewModel()) {
+    val searchQuery by viewModel.searchQuery.collectAsState()
+    val searchResults by viewModel.searchResults.collectAsState()
+    
+    var showAddDialog by remember { mutableStateOf(false) }
+
+    Scaffold(
+        floatingActionButton = {
+            FloatingActionButton(
+                onClick = { showAddDialog = true },
+                containerColor = MaterialTheme.colorScheme.primary
+            ) {
+                Icon(Icons.Default.Add, contentDescription = "Add Note")
+            }
+        }
+    ) { padding ->
+        Column(modifier = Modifier.padding(padding).fillMaxSize()) {
+            // Header
+            Text(
+                text = "✅ DESUGARING ! 🚀 HOT  ",
+                style = MaterialTheme.typography.displaySmall,
+                modifier = Modifier.padding(start = 16.dp, top = 16.dp, bottom = 20.dp)
+            )
+
+            // Search Bar
+            OutlinedTextField(
+                value = searchQuery,
+                onValueChange = viewModel::onSearchQueryChanged,
+                placeholder = { Text("Search note or ...") },
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 8.dp),
+                shape = MaterialTheme.shapes.extraLarge,
+                colors = TextFieldDefaults.colors(
+                    focusedIndicatorColor = Color.Transparent,
+                    unfocusedIndicatorColor = Color.Transparent
+                )
+            )
+
+            LazyVerticalStaggeredGrid(
+                columns = StaggeredGridCells.Fixed(2),
+                contentPadding = PaddingValues(16.dp),
+                horizontalArrangement = Arrangement.spacedBy(12.dp),
+                verticalItemSpacing = 12.dp
+            ) {
+                items(searchResults) { note ->
+                    NoteItem(note = note, onDelete = { viewModel.deleteNote(note) })
+                }
+            }
+        }
+
+        if (showAddDialog) {
+            AddNoteDialog(
+                onDismiss = { showAddDialog = false },
+                onAdd = { content ->
+                    viewModel.addNote(content)
+                    showAddDialog = false
+                },
+                viewModel = viewModel
+            )
+        }
+    }
+}
+
+@Composable
+fun NoteItem(note: Note, onDelete: () -> Unit) {
+    Card(
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant),
+        shape = MaterialTheme.shapes.medium
+    ) {
+        Column(modifier = Modifier.padding(12.dp)) {
+            Text(
+                text = note.content, 
+                style = MaterialTheme.typography.bodyLarge,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+            
+            if (note.tags.isNotEmpty()) {
+                Spacer(modifier = Modifier.height(12.dp))
+                Row(
+                    modifier = Modifier.horizontalScroll(rememberScrollState()),
+                    horizontalArrangement = Arrangement.spacedBy(4.dp)
+                ) {
+                    note.tags.forEach { tag ->
+                        AssistChip(
+                            onClick = {},
+                            label = { Text("#$tag", style = MaterialTheme.typography.labelSmall) },
+                            modifier = Modifier.height(24.dp)
+                        )
+                    }
+                }
+            }
+            
+            // Timestamp (optional, maybe too much clutter)
+        }
+    }
+}
+
+@Composable
+fun AddNoteDialog(onDismiss: () -> Unit, onAdd: (String) -> Unit, viewModel: NotesViewModel) {
+    var content by remember { mutableStateOf("") }
+    // Live tagging
+    val suggestedTags = viewModel.getSuggestedTags(content)
+
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text("New Note") },
+        text = {
+            Column {
+                OutlinedTextField(
+                    value = content,
+                    onValueChange = { content = it },
+                    placeholder = { Text("Type something...") },
+                    minLines = 3,
+                    modifier = Modifier.fillMaxWidth()
+                )
+                
+                Spacer(modifier = Modifier.height(16.dp))
+                
+                Text("Detected Tags:", style = MaterialTheme.typography.labelMedium)
+                if (suggestedTags.isEmpty()) {
+                    Text("None", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.outline)
+                } else {
+                    Row(
+                        modifier = Modifier.horizontalScroll(rememberScrollState()),
+                        horizontalArrangement = Arrangement.spacedBy(4.dp)
+                    ) {
+                        suggestedTags.forEach { tag ->
+                            SuggestionChip(
+                                onClick = {},
+                                label = { Text(tag) }
+                            )
+                        }
+                    }
+                }
+            }
+        },
+        confirmButton = {
+            Button(
+                onClick = { onAdd(content) },
+                enabled = content.isNotBlank()
+            ) {
+                Text("Save")
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text("Cancel")
+            }
+        }
+    )
+}
+
+
+
+
+
+
+// Trigger hot reload 10

package/template/base/app/src/main/java/__PACKAGE_PATH__/ui/NotesViewModel.kt

@@ -0,0 +1,58 @@
+package {{PACKAGE_NAME}}.ui
+
+import android.app.Application
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import {{PACKAGE_NAME}}.data.AppDatabase
+import {{PACKAGE_NAME}}.data.Note
+import {{PACKAGE_NAME}}.logic.TaggingEngine
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+
+class NotesViewModel(application: Application) : AndroidViewModel(application) {
+    private val dao = AppDatabase.getDatabase(application).noteDao()
+    private val taggingEngine = TaggingEngine()
+    
+    // For search
+    private val _searchQuery = MutableStateFlow("")
+    val searchQuery = _searchQuery.asStateFlow()
+    
+    // All notes from DB
+    val notes = dao.getAllNotes()
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())
+
+    // Search results: Use combine to filter locally for responsiveness, or use DAO search
+    val searchResults = combine(notes, _searchQuery) { list, query ->
+        if (query.isBlank()) list
+        else list.filter { it.content.contains(query, ignoreCase = true) || it.tags.any { tag -> tag.contains(query, ignoreCase = true) } }
+    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())
+
+    fun onSearchQueryChanged(query: String) {
+        _searchQuery.value = query
+    }
+
+    fun addNote(content: String) {
+        if (content.isBlank()) return
+        val tags = taggingEngine.autoTag(content)
+        val note = Note(content = content, tags = tags)
+        viewModelScope.launch {
+            dao.insertNote(note)
+        }
+    }
+    
+    fun deleteNote(note: Note) {
+        viewModelScope.launch {
+            dao.deleteNote(note)
+        }
+    }
+    
+    // Trigger full build for client update 7 (Fix Duplicate Renderers)
+    fun getSuggestedTags(content: String): List<String> {
+        return taggingEngine.autoTag(content)
+    }
+}

package/template/base/app/src/main/java/__PACKAGE_PATH__/ui/TestScreen.kt

@@ -0,0 +1,12 @@
+package {{PACKAGE_NAME}}.ui
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+
+@Composable
+fun TestScreen() {
+    Column {
+        Text("Hello Test 12 - HOT RELOAD TEST")
+    }
+}

package/template/base/app/src/main/res/values/colors.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="purple_200">#FFBB86FC</color>
+    <color name="purple_500">#FF6200EE</color>
+    <color name="purple_700">#FF3700B3</color>
+    <color name="teal_200">#FF03DAC5</color>
+    <color name="teal_700">#FF018786</color>
+    <color name="black">#FF000000</color>
+    <color name="white">#FFFFFFFF</color>
+</resources>

package/template/base/app/src/main/res/values/strings.xml

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

package/template/base/app/src/main/res/values/themes.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="Theme.{{THEME_NAME}}" parent="Theme.AppCompat.Light.NoActionBar">
+        <!-- Customize your theme here -->
+        <item name="colorPrimary">@color/purple_500</item>
+        <item name="colorPrimaryDark">@color/purple_700</item>
+        <item name="colorAccent">@color/teal_200</item>
+    </style>
+</resources>

package/template/base/app/src/main/res/xml/network_security_config.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+    <base-config cleartextTrafficPermitted="true">
+        <trust-anchors>
+            <certificates src="system" />
+        </trust-anchors>
+    </base-config>
+</network-security-config>

package/template/base/app/src/main/res/xml/provider_paths.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <cache-path name="cache" path="." />
+</paths>