@shaykec/app-agent 1.0.5 → 1.0.7

package/templates/android/TaskTemplate/tests/07_search_filter.yaml

@@ -1,6 +1,12 @@
 appId: ${APP_PACKAGE_NAME}
 ---
+- clearState
 - launchApp
+- extendedWaitUntil:
+    visible:
+      - "Inbox"
+    timeout: 10000
+# Skip onboarding
 - tapOn:
     text: "Skip"
     optional: true
@@ -8,11 +14,69 @@ appId: ${APP_PACKAGE_NAME}
     text: "Get Started"
     optional: true
 - tapOn:
-    id: "tab_bar_search"
-- assertVisible: "Search"
+    text: "Continue"
+    optional: true
+# Ensure we're on Inbox tab
+- assertVisible:
+    text: "Inbox"
+# Create a test task if needed
+- tapOn:
+    id: "inbox_add_task_button"
+    optional: true
+- assertVisible:
+    id: "task_detail_title_field"
+    optional: true
 - inputText:
-    text: "budget"
-- assertVisible: ".*budget.*"
+    id: "task_detail_title_field"
+    text: "Searchable Task"
+    optional: true
+- tapOn:
+    id: "task_detail_save_button"
+    optional: true
+- back
+    optional: true
+# Look for search field (may be in navigation bar or as a button)
+- assertVisible:
+    text: "Search"
+    optional: true
+# If search is accessible via button, tap it
+- tapOn:
+    text: "Search"
+    optional: true
+# If search field appears, input search query
 - inputText:
-    text: "Work"
-- assertVisible: ".*Work.*"
+    text: "Searchable"
+    optional: true
+# Verify search results or empty state
+- assertVisible:
+    id: "inbox_task_0_card"
+    optional: true
+- assertVisible:
+    id: "inbox_empty_state"
+    optional: true
+# Clear search if needed
+- back
+    optional: true
+# Test filter functionality if available
+- assertVisible:
+    text: "Filter"
+    optional: true
+- tapOn:
+    text: "Filter"
+    optional: true
+# Navigate to Projects tab to test project filtering
+- tapOn:
+    text: "Projects"
+- assertVisible:
+    text: "Projects"
+- assertVisible:
+    id: "project_list_project_0_card"
+    optional: true
+- assertVisible:
+    id: "project_list_empty_state"
+    optional: true
+# Return to Inbox
+- tapOn:
+    text: "Inbox"
+- assertVisible:
+    text: "Inbox"

package/templates/android/TrackTemplate/TESTING_MANIFEST.md

@@ -31,6 +31,7 @@ Test tags follow the pattern: `{screen}_{element}_{identifier}`
 | `today_habit_{index}_card` | Card | Habit card (indexed by position) |
 | `today_habit_{index}_checkbox` | Box (clickable) | Habit completion checkbox |
 | `today_empty_state_button` | Button | "Add Your First Habit" button |
+| `today_empty_state` | Column | Empty state view when no habits exist |
 
 ## Dashboard Screen (`DashboardScreen.kt`)
 
@@ -41,6 +42,7 @@ Test tags follow the pattern: `{screen}_{element}_{identifier}`
 | `dashboard_calendar_card` | Card | Calendar heat map card |
 | `dashboard_habit_{index}_card` | Row | Habit performance row (indexed) |
 | `dashboard_insight_{index}_card` | Row | Insight row (indexed) |
+| `dashboard_empty_state` | Column | Empty state view when no habits exist |
 
 ## Habits List Screen (`HabitsListScreen.kt`)
 
@@ -50,6 +52,7 @@ Test tags follow the pattern: `{screen}_{element}_{identifier}`
 | `habits_fab` | FloatingActionButton | Floating action button |
 | `habits_filter_{name}_chip` | FilterChip | Category filter chip (name: category ID or "all") |
 | `habits_habit_{index}_card` | Card | Habit card (indexed by position) |
+| `habits_empty_state` | Column | Empty state view when no habits exist |
 
 ## Habit Detail Screen (`HabitDetailScreen.kt`)
 
@@ -85,6 +88,7 @@ Test tags follow the pattern: `{screen}_{element}_{identifier}`
 |----------|---------|-------------|
 | `achievements_summary_card` | Card | Summary card with unlocked count |
 | `achievements_achievement_{index}_card` | Card | Achievement card (indexed, unlocked or locked) |
+| `achievements_empty_state` | Column | Empty state view when no achievements exist |
 
 ## Settings Screen (`SettingsScreen.kt`)
 

package/templates/android/TrackTemplate/app/build.gradle.kts

@@ -77,7 +77,12 @@ dependencies {
     implementation(libs.coil.compose)
     
     // JSON Serialization
-    implementation("com.google.code.gson:gson:2.10.1")
+    implementation(libs.gson)
+    
+    // Room
+    implementation(libs.room.runtime)
+    implementation(libs.room.ktx)
+    ksp(libs.room.compiler)
     
     // Testing
     testImplementation(libs.junit)

package/templates/android/TrackTemplate/app/src/main/kotlin/com/appship/track/TrackApplication.kt

@@ -3,6 +3,7 @@ package com.appship.track
 import android.app.Application
 import com.appship.track.data.LocalPersistence
 import com.appship.track.data.NetworkMonitor
+import com.appship.track.data.local.LocalStorageProvider
 import dagger.hilt.android.HiltAndroidApp
 
 @HiltAndroidApp
@@ -11,5 +12,6 @@ class TrackApplication : Application() {
         super.onCreate()
         NetworkMonitor.register(this)
         LocalPersistence.initialize(this)
+        LocalStorageProvider.initialize(this)
     }
 }

package/templates/android/TrackTemplate/app/src/main/kotlin/com/appship/track/core/components/EmptyStateView.kt

@@ -0,0 +1,89 @@
+package com.appship.track.core.components
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material3.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+
+/**
+ * Configuration for EmptyStateView display.
+ */
+data class EmptyStateConfig(
+    val message: String,
+    val icon: @Composable () -> Unit = {},
+    val actionLabel: String? = null,
+    val onAction: (() -> Unit)? = null
+)
+
+/**
+ * Reusable empty state component for displaying when lists are empty.
+ */
+@Composable
+fun EmptyStateView(
+    config: EmptyStateConfig,
+    modifier: Modifier = Modifier
+) {
+    Column(
+        modifier = modifier
+            .fillMaxWidth()
+            .padding(32.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Center
+    ) {
+        config.icon()
+        
+        Spacer(modifier = Modifier.height(16.dp))
+        
+        Text(
+            text = config.message,
+            style = MaterialTheme.typography.bodyLarge,
+            color = MaterialTheme.colorScheme.onSurfaceVariant
+        )
+        
+        config.actionLabel?.let { label ->
+            config.onAction?.let { action ->
+                Spacer(modifier = Modifier.height(24.dp))
+                Button(
+                    onClick = action,
+                    modifier = Modifier.padding(horizontal = 16.dp)
+                ) {
+                    Icon(
+                        imageVector = Icons.Default.Add,
+                        contentDescription = null,
+                        modifier = Modifier.size(18.dp)
+                    )
+                    Spacer(modifier = Modifier.width(8.dp))
+                    Text(label)
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Preset configurations for common empty states.
+ */
+object EmptyStatePresets {
+    fun noItems(
+        message: String,
+        onAdd: (() -> Unit)? = null
+    ): EmptyStateConfig {
+        return EmptyStateConfig(
+            message = message,
+            icon = {
+                Icon(
+                    imageVector = Icons.Default.Add,
+                    contentDescription = null,
+                    modifier = Modifier.size(48.dp),
+                    tint = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            },
+            actionLabel = if (onAdd != null) "Add" else null,
+            onAction = onAdd
+        )
+    }
+}

package/templates/android/TrackTemplate/app/src/main/kotlin/com/appship/track/data/DataRepository.kt

@@ -23,7 +23,7 @@ interface DataRepository {
     fun createHabit(habit: Habit)
     fun updateHabit(habitId: String, update: (Habit) -> Habit)
     fun deleteHabit(habitId: String)
-    fun archiveHabit(habitId: String, archived: Boolean = true)
+    fun archiveHabit(habitId: String, archived: Boolean)
     fun toggleHabitCompletion(habitId: String, date: LocalDate, completed: Boolean)
     
     // CRUD Operations for Achievements

package/templates/android/TrackTemplate/app/src/main/kotlin/com/appship/track/data/DataSourceResolver.kt

@@ -15,8 +15,7 @@ object DataSourceResolver {
     val repository: DataRepository
         get() = when (AppConfig.DataSource.active) {
             AppConfig.DataSource.SourceType.LOCAL_STORAGE -> {
-                // TODO: Return LocalStorageProvider once implemented
-                MockDataProvider
+                com.appship.track.data.local.LocalStorageProvider.getInstance()
             }
             AppConfig.DataSource.SourceType.MOCK -> MockDataProvider
         }

package/templates/android/TrackTemplate/app/src/main/kotlin/com/appship/track/data/local/AchievementEntity.kt

@@ -0,0 +1,53 @@
+package com.appship.track.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.track.data.Achievement
+import com.appship.track.data.AchievementType
+import java.time.LocalDateTime
+
+/**
+ * Room entity for Achievement persistence.
+ */
+@Entity(tableName = "achievements")
+data class AchievementEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val description: String = "",
+    val icon: String = "star",
+    val requirement: Int = 1,
+    val type: String = "TOTAL_COMPLETIONS",
+    val isUnlocked: Boolean = false,
+    val unlockedAt: Long? = null, // LocalDateTime as epoch millis
+    val progress: Int = 0
+) {
+    fun toAchievement(): Achievement {
+        return Achievement(
+            id = id,
+            title = title,
+            description = description,
+            icon = icon,
+            requirement = requirement,
+            type = AchievementType.valueOf(type),
+            isUnlocked = isUnlocked,
+            unlockedAt = unlockedAt?.let { LocalDateTime.ofEpochSecond(it / 1000, 0, java.time.ZoneOffset.UTC) },
+            progress = progress
+        )
+    }
+
+    companion object {
+        fun fromAchievement(achievement: Achievement): AchievementEntity {
+            return AchievementEntity(
+                id = achievement.id,
+                title = achievement.title,
+                description = achievement.description,
+                icon = achievement.icon,
+                requirement = achievement.requirement,
+                type = achievement.type.name,
+                isUnlocked = achievement.isUnlocked,
+                unlockedAt = achievement.unlockedAt?.toEpochSecond(java.time.ZoneOffset.UTC)?.times(1000),
+                progress = achievement.progress
+            )
+        }
+    }
+}

package/templates/android/TrackTemplate/app/src/main/kotlin/com/appship/track/data/local/AppDao.kt

@@ -0,0 +1,93 @@
+package com.appship.track.data.local
+
+import androidx.room.*
+
+/**
+ * Room DAO for all CRUD operations.
+ */
+@Dao
+interface AppDao {
+
+    // — Habits —
+
+    @Query("SELECT * FROM habits WHERE isArchived = 0 ORDER BY createdAt DESC")
+    suspend fun getAllHabits(): List<HabitEntity>
+
+    @Query("SELECT * FROM habits WHERE id = :id LIMIT 1")
+    suspend fun getHabitById(id: String): HabitEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertHabit(habit: HabitEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertHabits(habits: List<HabitEntity>)
+
+    @Update
+    suspend fun updateHabit(habit: HabitEntity)
+
+    @Delete
+    suspend fun deleteHabit(habit: HabitEntity)
+
+    @Query("SELECT COUNT(*) FROM habits")
+    suspend fun habitCount(): Int
+
+    // — Habit Entries —
+
+    @Query("SELECT * FROM habit_entries WHERE habitId = :habitId ORDER BY date DESC")
+    suspend fun getEntriesByHabitId(habitId: String): List<HabitEntryEntity>
+
+    @Query("SELECT * FROM habit_entries WHERE habitId = :habitId AND date = :dateEpochDay LIMIT 1")
+    suspend fun getEntryByHabitIdAndDate(habitId: String, dateEpochDay: Long): HabitEntryEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertEntry(entry: HabitEntryEntity)
+
+    @Update
+    suspend fun updateEntry(entry: HabitEntryEntity)
+
+    @Delete
+    suspend fun deleteEntry(entry: HabitEntryEntity)
+
+    @Query("DELETE FROM habit_entries WHERE habitId = :habitId")
+    suspend fun deleteEntriesByHabitId(habitId: String)
+
+    // — Achievements —
+
+    @Query("SELECT * FROM achievements ORDER BY requirement ASC")
+    suspend fun getAllAchievements(): List<AchievementEntity>
+
+    @Query("SELECT * FROM achievements WHERE id = :id LIMIT 1")
+    suspend fun getAchievementById(id: String): AchievementEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertAchievement(achievement: AchievementEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertAchievements(achievements: List<AchievementEntity>)
+
+    @Update
+    suspend fun updateAchievement(achievement: AchievementEntity)
+
+    @Delete
+    suspend fun deleteAchievement(achievement: AchievementEntity)
+
+    @Query("SELECT COUNT(*) FROM achievements")
+    suspend fun achievementCount(): Int
+
+    // — Streaks —
+
+    @Query("SELECT * FROM streaks WHERE habitId = :habitId LIMIT 1")
+    suspend fun getStreakByHabitId(habitId: String): StreakEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertStreak(streak: StreakEntity)
+
+    @Update
+    suspend fun updateStreak(streak: StreakEntity)
+
+    @Delete
+    suspend fun deleteStreak(streak: StreakEntity)
+
+    @Query("DELETE FROM streaks WHERE habitId = :habitId")
+    suspend fun deleteStreakByHabitId(habitId: String)
+}

package/templates/android/TrackTemplate/app/src/main/kotlin/com/appship/track/data/local/AppDatabase.kt

@@ -0,0 +1,39 @@
+package com.appship.track.data.local
+
+import android.content.Context
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+
+/**
+ * Room database for local storage.
+ * Holds all entity tables.
+ */
+@Database(
+    entities = [
+        HabitEntity::class,
+        HabitEntryEntity::class,
+        AchievementEntity::class,
+        StreakEntity::class
+    ],
+    version = 1,
+    exportSchema = false
+)
+abstract class AppDatabase : RoomDatabase() {
+    abstract fun appDao(): AppDao
+
+    companion object {
+        @Volatile
+        private var INSTANCE: AppDatabase? = null
+
+        fun getInstance(context: Context): AppDatabase {
+            return INSTANCE ?: synchronized(this) {
+                INSTANCE ?: Room.databaseBuilder(
+                    context.applicationContext,
+                    AppDatabase::class.java,
+                    "track_database"
+                ).build().also { INSTANCE = it }
+            }
+        }
+    }
+}

package/templates/android/TrackTemplate/app/src/main/kotlin/com/appship/track/data/local/HabitEntity.kt

@@ -0,0 +1,75 @@
+package com.appship.track.data.local
+
+import androidx.compose.ui.graphics.Color
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.track.data.Habit
+import com.appship.track.data.HabitFrequency
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import java.time.LocalDateTime
+
+/**
+ * Room entity for Habit persistence.
+ * Stores reminderDays as JSON string, color as Long (Color value).
+ */
+@Entity(tableName = "habits")
+data class HabitEntity(
+    @PrimaryKey val id: String,
+    val name: String = "",
+    val description: String? = null,
+    val icon: String = "star",
+    val color: Long = 0xFF3B82F6, // Color as Long
+    val categoryId: String = "",
+    val frequency: String = "DAILY",
+    val targetValue: Int = 1,
+    val unit: String? = null,
+    val reminderTime: String? = null,
+    val reminderDaysJson: String? = null,
+    val isArchived: Boolean = false,
+    val createdAt: Long = System.currentTimeMillis() // LocalDateTime as epoch millis
+) {
+    fun toHabit(): Habit {
+        val reminderDays: List<Int>? = reminderDaysJson?.let {
+            val gson = Gson()
+            val type = object : TypeToken<List<Int>>() {}.type
+            gson.fromJson(it, type)
+        }
+        return Habit(
+            id = id,
+            name = name,
+            description = description,
+            icon = icon,
+            color = color,
+            categoryId = categoryId,
+            frequency = HabitFrequency.valueOf(frequency),
+            targetValue = targetValue,
+            unit = unit,
+            reminderTime = reminderTime,
+            reminderDays = reminderDays,
+            isArchived = isArchived,
+            createdAt = LocalDateTime.ofEpochSecond(createdAt / 1000, 0, java.time.ZoneOffset.UTC)
+        )
+    }
+
+    companion object {
+        fun fromHabit(habit: Habit): HabitEntity {
+            val gson = Gson()
+            return HabitEntity(
+                id = habit.id,
+                name = habit.name,
+                description = habit.description,
+                icon = habit.icon,
+                color = habit.color,
+                categoryId = habit.categoryId,
+                frequency = habit.frequency.name,
+                targetValue = habit.targetValue,
+                unit = habit.unit,
+                reminderTime = habit.reminderTime,
+                reminderDaysJson = habit.reminderDays?.let { gson.toJson(it) },
+                isArchived = habit.isArchived,
+                createdAt = habit.createdAt.toEpochSecond(java.time.ZoneOffset.UTC) * 1000
+            )
+        }
+    }
+}

package/templates/android/TrackTemplate/app/src/main/kotlin/com/appship/track/data/local/HabitEntryEntity.kt

@@ -0,0 +1,50 @@
+package com.appship.track.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.track.data.HabitEntry
+import java.time.LocalDate
+import java.time.LocalDateTime
+
+/**
+ * Room entity for HabitEntry persistence.
+ */
+@Entity(tableName = "habit_entries")
+data class HabitEntryEntity(
+    @PrimaryKey val id: String,
+    val habitId: String,
+    val date: Long, // LocalDate as epoch day
+    val value: Int = 0,
+    val isCompleted: Boolean = false,
+    val note: String? = null,
+    val mood: Int? = null,
+    val completedAt: Long? = null // LocalDateTime as epoch millis
+) {
+    fun toHabitEntry(): HabitEntry {
+        return HabitEntry(
+            id = id,
+            habitId = habitId,
+            date = LocalDate.ofEpochDay(date),
+            value = value,
+            isCompleted = isCompleted,
+            note = note,
+            mood = mood,
+            completedAt = completedAt?.let { LocalDateTime.ofEpochSecond(it / 1000, 0, java.time.ZoneOffset.UTC) }
+        )
+    }
+
+    companion object {
+        fun fromHabitEntry(entry: HabitEntry): HabitEntryEntity {
+            return HabitEntryEntity(
+                id = entry.id,
+                habitId = entry.habitId,
+                date = entry.date.toEpochDay(),
+                value = entry.value,
+                isCompleted = entry.isCompleted,
+                note = entry.note,
+                mood = entry.mood,
+                completedAt = entry.completedAt?.toEpochSecond(java.time.ZoneOffset.UTC)?.times(1000)
+            )
+        }
+    }
+}