@shaykec/app-agent 1.0.5 → 1.0.6

package/templates/android/MediaTemplate/tests/08_full_e2e.yaml

@@ -1,39 +1,53 @@
 appId: ${APP_PACKAGE_NAME}
 ---
+- clearState
 - launchApp
-# Navigate through tabs
+- extendedWaitUntil:
+    visible:
+      - "Home"
+      - id: "home_search_bar"
+    timeout: 10000
 - tapOn:
-    id: "tab_bar_browse"
-- tapOn:
-    id: "browse_category_0_card"
-# Play media
+    id: "onboarding_skip_button"
+    optional: true
 - tapOn:
+    id: "onboarding_get_started_button"
+    optional: true
+- assertVisible:
     id: "home_featured_0_card"
+    optional: true
+- tapOn:
+    id: "home_search_bar"
+- inputText: "Song"
+- tapOn:
+    id: "search_result_0_card"
+    optional: true
 - tapOn:
     id: "detail_play_button"
-# Use player controls
-- assertVisible:
-    id: "player_skip_forward_button"
-- assertVisible:
-    id: "player_skip_back_button"
+    optional: true
 - tapOn:
-    id: "player_play_pause_button"
-# Search
+    text: "Back"
+    optional: true
+- tapOn: "Browse"
 - tapOn:
-    id: "tab_bar_home"
+    id: "browse_category_0_card"
+    optional: true
 - tapOn:
-    id: "home_search_bar"
-- inputText: "podcast"
-- assertVisible:
-    id: "search_result_0_card"
+    id: "detail_play_button"
     optional: true
-# Library
 - tapOn:
-    id: "tab_bar_library"
-- assertVisible:
-    text: "Library"
-# Settings
+    text: "Back"
+    optional: true
+- tapOn: "Library"
+- tapOn:
+    id: "library_playlist_0_card"
+    optional: true
 - tapOn:
-    id: "tab_bar_settings"
+    text: "Back"
+    optional: true
+- tapOn: "Settings"
+- assertVisible:
+    - "Settings"
+- tapOn: "Home"
 - assertVisible:
-    text: "Settings"
+    - "Home"

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

@@ -87,6 +87,11 @@ dependencies {
     // JSON Serialization
     implementation(libs.gson)
     
+    // Room
+    implementation(libs.room.runtime)
+    implementation(libs.room.ktx)
+    ksp(libs.room.compiler)
+    
     // Biometric Authentication
     implementation(libs.androidx.biometric)
     

package/templates/android/ReferenceTemplate/app/src/main/AndroidManifest.xml

@@ -17,7 +17,7 @@
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <application
-        android:name=".ShopApplication"
+        android:name=".ReferenceApplication"
         android:allowBackup="true"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="@xml/backup_rules"
@@ -25,29 +25,18 @@
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:theme="@style/Theme.ShopTemplate"
+        android:theme="@style/Theme.ReferenceTemplate"
         tools:targetApi="31">
         
         <activity
             android:name=".MainActivity"
             android:exported="true"
             android:label="@string/app_name"
-            android:theme="@style/Theme.ShopTemplate">
+            android:theme="@style/Theme.ReferenceTemplate">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
-            
-            <!-- Deep linking -->
-            <intent-filter android:autoVerify="true">
-                <action android:name="android.intent.action.VIEW" />
-                <category android:name="android.intent.category.DEFAULT" />
-                <category android:name="android.intent.category.BROWSABLE" />
-                <data
-                    android:scheme="https"
-                    android:host="shop.appship.com"
-                    android:pathPrefix="/product" />
-            </intent-filter>
         </activity>
     </application>
 

package/templates/android/ReferenceTemplate/app/src/main/kotlin/com/appship/reference/ReferenceApplication.kt

@@ -0,0 +1,16 @@
+package com.appship.reference
+
+import android.app.Application
+import com.appship.reference.data.local.LocalStorageProvider
+import dagger.hilt.android.HiltAndroidApp
+
+@HiltAndroidApp
+class ReferenceApplication : Application() {
+    override fun onCreate() {
+        super.onCreate()
+        // Initialize Room-backed local storage (no-op if DataSource is .MOCK)
+        if (AppConfig.DataSource.active == AppConfig.DataSource.SourceType.LOCAL_STORAGE) {
+            LocalStorageProvider.initialize(this)
+        }
+    }
+}

package/templates/android/ReferenceTemplate/app/src/main/kotlin/com/appship/reference/data/DataRepository.kt

@@ -0,0 +1,26 @@
+package com.appship.reference.data
+
+/**
+ * Abstracts the data layer. Both MockDataProvider and LocalStorageProvider
+ * implement this, allowing the app to swap data sources via AppConfig.DataSource.active.
+ *
+ * Screens and ViewModels depend on this interface rather than on a concrete implementation.
+ */
+interface DataRepository {
+    // Observable state
+    val tasks: List<Task>
+    val notes: List<Note>
+    val weeklySummaries: List<WeeklySummary>
+
+    // CRUD operations - Tasks
+    fun addTask(task: Task)
+    fun updateTask(task: Task)
+    fun deleteTask(task: Task)
+    fun toggleTaskCompletion(task: Task)
+
+    // CRUD operations - Notes
+    fun addNote(note: Note)
+    fun updateNote(note: Note)
+    fun deleteNote(note: Note)
+    fun toggleNotePin(note: Note)
+}

package/templates/android/ReferenceTemplate/app/src/main/kotlin/com/appship/reference/data/DataSourceResolver.kt

@@ -0,0 +1,25 @@
+package com.appship.reference.data
+
+import com.appship.reference.AppConfig
+import com.appship.reference.data.local.LocalStorageProvider
+
+/**
+ * Resolves the active [DataRepository] implementation based on [AppConfig.DataSource.active].
+ * Screens use this to obtain the correct data source without knowing the concrete type.
+ *
+ * Usage:
+ *   val repository = DataSourceResolver.repository
+ *   val tasks = repository.tasks
+ */
+object DataSourceResolver {
+    val repository: DataRepository
+        get() = when (AppConfig.DataSource.active) {
+            AppConfig.DataSource.SourceType.LOCAL_STORAGE -> {
+                LocalStorageProvider.getInstance()
+            }
+            AppConfig.DataSource.SourceType.MOCK -> {
+                // TODO: Return MockDataProvider once it exists
+                LocalStorageProvider.getInstance()
+            }
+        }
+}

package/templates/android/ReferenceTemplate/app/src/main/kotlin/com/appship/reference/data/Models.kt

@@ -0,0 +1,61 @@
+package com.appship.reference.data
+
+import java.util.Date
+
+/**
+ * Task model for the Daily Companion app.
+ */
+data class Task(
+    val id: String,
+    var title: String,
+    var description: String? = null,
+    var isCompleted: Boolean = false,
+    var dueDate: Date? = null,
+    var priority: TaskPriority = TaskPriority.MEDIUM,
+    var tags: List<String> = emptyList(),
+    var createdAt: Date = Date(),
+    var updatedAt: Date = Date()
+) {
+    enum class TaskPriority {
+        LOW, MEDIUM, HIGH, URGENT
+    }
+}
+
+/**
+ * Note model for the Daily Companion app.
+ */
+data class Note(
+    val id: String,
+    var title: String,
+    var content: String,
+    var attachments: List<NoteAttachment> = emptyList(),
+    var tags: List<String> = emptyList(),
+    var createdAt: Date = Date(),
+    var updatedAt: Date = Date(),
+    var isPinned: Boolean = false
+)
+
+/**
+ * Note attachment model.
+ */
+data class NoteAttachment(
+    val id: String,
+    val type: AttachmentType,
+    val url: String,
+    val thumbnailUrl: String? = null
+) {
+    enum class AttachmentType {
+        IMAGE, VIDEO, DOCUMENT
+    }
+}
+
+/**
+ * Weekly summary model for charts.
+ */
+data class WeeklySummary(
+    val id: String,
+    val date: Date,
+    val tasksCompleted: Int,
+    val notesCreated: Int,
+    val hoursWorked: Double
+)

package/templates/android/ReferenceTemplate/app/src/main/kotlin/com/appship/reference/data/local/AppDao.kt

@@ -0,0 +1,57 @@
+package com.appship.reference.data.local
+
+import androidx.room.*
+import kotlinx.coroutines.flow.Flow
+
+/**
+ * Room DAO for Task and Note CRUD operations.
+ */
+@Dao
+interface AppDao {
+
+    // — Tasks —
+
+    @Query("SELECT * FROM tasks ORDER BY createdAtMillis DESC")
+    suspend fun getAllTasks(): List<TaskEntity>
+
+    @Query("SELECT * FROM tasks WHERE id = :id LIMIT 1")
+    suspend fun getTaskById(id: String): TaskEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertTask(task: TaskEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertTasks(tasks: List<TaskEntity>)
+
+    @Update
+    suspend fun updateTask(task: TaskEntity)
+
+    @Delete
+    suspend fun deleteTask(task: TaskEntity)
+
+    @Query("SELECT COUNT(*) FROM tasks")
+    suspend fun taskCount(): Int
+
+    // — Notes —
+
+    @Query("SELECT * FROM notes ORDER BY createdAtMillis DESC")
+    suspend fun getAllNotes(): List<NoteEntity>
+
+    @Query("SELECT * FROM notes WHERE id = :id LIMIT 1")
+    suspend fun getNoteById(id: String): NoteEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertNote(note: NoteEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertNotes(notes: List<NoteEntity>)
+
+    @Update
+    suspend fun updateNote(note: NoteEntity)
+
+    @Delete
+    suspend fun deleteNote(note: NoteEntity)
+
+    @Query("SELECT COUNT(*) FROM notes")
+    suspend fun noteCount(): Int
+}

package/templates/android/ReferenceTemplate/app/src/main/kotlin/com/appship/reference/data/local/AppDatabase.kt

@@ -0,0 +1,37 @@
+package com.appship.reference.data.local
+
+import android.content.Context
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+
+/**
+ * Room database for local storage.
+ * Holds TaskEntity and NoteEntity tables.
+ */
+@Database(
+    entities = [
+        TaskEntity::class,
+        NoteEntity::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,
+                    "reference_database"
+                ).build().also { INSTANCE = it }
+            }
+        }
+    }
+}

package/templates/android/ReferenceTemplate/app/src/main/kotlin/com/appship/reference/data/local/LocalStorageProvider.kt

@@ -0,0 +1,277 @@
+package com.appship.reference.data.local
+
+import android.content.Context
+import android.content.SharedPreferences
+import com.appship.reference.AppConfig
+import com.appship.reference.data.DataRepository
+import com.appship.reference.data.Task
+import com.appship.reference.data.Note
+import com.appship.reference.data.WeeklySummary
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import java.util.Calendar
+import java.util.Date
+
+/**
+ * Room-backed implementation of [DataRepository].
+ * Stores tasks and notes in a local SQLite database.
+ * Pre-seeds default data from MockDataProvider on first launch.
+ *
+ * Call [initialize] with an Android Context before using.
+ */
+class LocalStorageProvider private constructor(
+    private val dao: AppDao,
+    private val prefs: SharedPreferences,
+    private val scope: CoroutineScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+) : DataRepository {
+
+    private val _tasks = MutableStateFlow<List<Task>>(emptyList())
+    override val tasks: List<Task> get() = _tasks.value
+
+    private val _notes = MutableStateFlow<List<Note>>(emptyList())
+    override val notes: List<Note> get() = _notes.value
+
+    private val _weeklySummaries = MutableStateFlow<List<WeeklySummary>>(emptyList())
+    override val weeklySummaries: List<WeeklySummary> get() = _weeklySummaries.value
+
+    fun loadData() {
+        scope.launch {
+            // Seed on first launch
+            if (dao.taskCount() == 0 && dao.noteCount() == 0) {
+                seedDefaultData()
+            }
+            refreshTasks()
+            refreshNotes()
+            generateWeeklySummaries()
+        }
+    }
+
+    override fun addTask(task: Task) {
+        scope.launch {
+            dao.insertTask(TaskEntity.fromTask(task))
+            refreshTasks()
+            generateWeeklySummaries()
+        }
+    }
+
+    override fun updateTask(task: Task) {
+        scope.launch {
+            dao.updateTask(TaskEntity.fromTask(task))
+            refreshTasks()
+            generateWeeklySummaries()
+        }
+    }
+
+    override fun deleteTask(task: Task) {
+        scope.launch {
+            dao.getTaskById(task.id)?.let { dao.deleteTask(it) }
+            refreshTasks()
+            generateWeeklySummaries()
+        }
+    }
+
+    override fun toggleTaskCompletion(task: Task) {
+        scope.launch {
+            val updated = task.copy(
+                isCompleted = !task.isCompleted,
+                updatedAt = Date()
+            )
+            dao.updateTask(TaskEntity.fromTask(updated))
+            refreshTasks()
+            generateWeeklySummaries()
+        }
+    }
+
+    override fun addNote(note: Note) {
+        scope.launch {
+            dao.insertNote(NoteEntity.fromNote(note))
+            refreshNotes()
+            generateWeeklySummaries()
+        }
+    }
+
+    override fun updateNote(note: Note) {
+        scope.launch {
+            dao.updateNote(NoteEntity.fromNote(note))
+            refreshNotes()
+            generateWeeklySummaries()
+        }
+    }
+
+    override fun deleteNote(note: Note) {
+        scope.launch {
+            dao.getNoteById(note.id)?.let { dao.deleteNote(it) }
+            refreshNotes()
+            generateWeeklySummaries()
+        }
+    }
+
+    override fun toggleNotePin(note: Note) {
+        scope.launch {
+            val updated = note.copy(
+                isPinned = !note.isPinned,
+                updatedAt = Date()
+            )
+            dao.updateNote(NoteEntity.fromNote(updated))
+            refreshNotes()
+        }
+    }
+
+    // MARK: - Private helpers
+
+    private suspend fun refreshTasks() {
+        _tasks.value = dao.getAllTasks().map { it.toTask() }
+    }
+
+    private suspend fun refreshNotes() {
+        _notes.value = dao.getAllNotes().map { it.toNote() }
+    }
+
+    private suspend fun seedDefaultData() {
+        // Create default tasks and notes (similar to MockDataProvider)
+        val defaultTasks = listOf(
+            Task(
+                id = "task1",
+                title = "Complete project proposal",
+                description = "Write and review the Q1 project proposal",
+                isCompleted = false,
+                dueDate = Date(System.currentTimeMillis() + 3 * 24 * 60 * 60 * 1000L),
+                priority = Task.TaskPriority.HIGH,
+                tags = listOf("work", "urgent"),
+                createdAt = Date(System.currentTimeMillis() - 2 * 24 * 60 * 60 * 1000L),
+                updatedAt = Date(System.currentTimeMillis() - 60 * 60 * 1000L)
+            ),
+            Task(
+                id = "task2",
+                title = "Review team feedback",
+                description = "Go through all feedback from the team meeting",
+                isCompleted = true,
+                dueDate = Date(System.currentTimeMillis() - 24 * 60 * 60 * 1000L),
+                priority = Task.TaskPriority.MEDIUM,
+                tags = listOf("work"),
+                createdAt = Date(System.currentTimeMillis() - 3 * 24 * 60 * 60 * 1000L),
+                updatedAt = Date(System.currentTimeMillis() - 2 * 60 * 60 * 1000L)
+            ),
+            Task(
+                id = "task3",
+                title = "Plan weekend trip",
+                description = "Research destinations and book accommodations",
+                isCompleted = false,
+                dueDate = Date(System.currentTimeMillis() + 7 * 24 * 60 * 60 * 1000L),
+                priority = Task.TaskPriority.LOW,
+                tags = listOf("personal"),
+                createdAt = Date(System.currentTimeMillis() - 24 * 60 * 60 * 1000L),
+                updatedAt = Date(System.currentTimeMillis() - 60 * 60 * 1000L)
+            )
+        )
+
+        val defaultNotes = listOf(
+            Note(
+                id = "note1",
+                title = "Meeting Notes - Product Planning",
+                content = "Discussed Q2 roadmap and feature priorities. Key decisions:\n- Focus on user engagement\n- Improve onboarding flow\n- Add analytics dashboard",
+                attachments = emptyList(),
+                tags = listOf("work", "meeting"),
+                createdAt = Date(System.currentTimeMillis() - 2 * 24 * 60 * 60 * 1000L),
+                updatedAt = Date(System.currentTimeMillis() - 60 * 60 * 1000L),
+                isPinned = true
+            ),
+            Note(
+                id = "note2",
+                title = "Recipe Ideas",
+                content = "Want to try:\n- Homemade pasta\n- Sourdough bread\n- Tiramisu",
+                attachments = emptyList(),
+                tags = listOf("personal", "cooking"),
+                createdAt = Date(System.currentTimeMillis() - 5 * 24 * 60 * 60 * 1000L),
+                updatedAt = Date(System.currentTimeMillis() - 4 * 24 * 60 * 60 * 1000L),
+                isPinned = false
+            ),
+            Note(
+                id = "note3",
+                title = "Book Recommendations",
+                content = "To read:\n1. The Design of Everyday Things\n2. Atomic Habits\n3. Sapiens",
+                attachments = emptyList(),
+                tags = listOf("personal", "books"),
+                createdAt = Date(System.currentTimeMillis() - 7 * 24 * 60 * 60 * 1000L),
+                updatedAt = Date(System.currentTimeMillis() - 6 * 24 * 60 * 60 * 1000L),
+                isPinned = false
+            )
+        )
+
+        dao.insertTasks(defaultTasks.map { TaskEntity.fromTask(it) })
+        dao.insertNotes(defaultNotes.map { NoteEntity.fromNote(it) })
+    }
+
+    private suspend fun generateWeeklySummaries() {
+        val calendar = Calendar.getInstance()
+        val now = Date()
+        val summaries = mutableListOf<WeeklySummary>()
+
+        // Generate summaries for the last 8 weeks
+        for (weekOffset in 0..<8) {
+            calendar.time = now
+            calendar.add(Calendar.WEEK_OF_YEAR, -weekOffset)
+            calendar.set(Calendar.DAY_OF_WEEK, calendar.firstDayOfWeek)
+            val weekStart = calendar.time
+
+            calendar.add(Calendar.DAY_OF_MONTH, 7)
+            val weekEnd = calendar.time
+
+            val weekTasks = _tasks.value.filter { task ->
+                task.isCompleted && task.updatedAt >= weekStart && task.updatedAt < weekEnd
+            }
+
+            val weekNotes = _notes.value.filter { note ->
+                note.createdAt >= weekStart && note.createdAt < weekEnd
+            }
+
+            // Estimate hours worked (simplified: 1 hour per completed task, 0.5 hours per note)
+            val hoursWorked = weekTasks.size.toDouble() + (weekNotes.size * 0.5)
+
+            summaries.add(
+                WeeklySummary(
+                    id = "week-$weekOffset",
+                    date = weekStart,
+                    tasksCompleted = weekTasks.size,
+                    notesCreated = weekNotes.size,
+                    hoursWorked = hoursWorked
+                )
+            )
+        }
+
+        _weeklySummaries.value = summaries.sortedByDescending { it.date }
+    }
+
+    companion object {
+        @Volatile
+        private var INSTANCE: LocalStorageProvider? = null
+
+        /**
+         * Initialize with Android context. Call from Application.onCreate().
+         */
+        fun initialize(context: Context) {
+            if (INSTANCE == null) {
+                synchronized(this) {
+                    if (INSTANCE == null) {
+                        val db = AppDatabase.getInstance(context)
+                        val prefs = context.getSharedPreferences("reference_prefs", Context.MODE_PRIVATE)
+                        INSTANCE = LocalStorageProvider(db.appDao(), prefs).also {
+                            it.loadData()
+                        }
+                    }
+                }
+            }
+        }
+
+        /**
+         * Returns the singleton instance. Must call [initialize] first.
+         */
+        fun getInstance(): LocalStorageProvider {
+            return INSTANCE ?: error(
+                "LocalStorageProvider not initialized. Call LocalStorageProvider.initialize(context) first."
+            )
+        }
+    }
+}

package/templates/android/ReferenceTemplate/app/src/main/kotlin/com/appship/reference/data/local/NoteEntity.kt

@@ -0,0 +1,57 @@
+package com.appship.reference.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.reference.data.Note
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+
+/**
+ * Room entity for Note persistence.
+ * Stores attachments and tags as JSON strings.
+ */
+@Entity(tableName = "notes")
+data class NoteEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val content: String = "",
+    val attachmentsJson: String = "[]",
+    val tagsJson: String = "[]",
+    val createdAtMillis: Long = System.currentTimeMillis(),
+    val updatedAtMillis: Long = System.currentTimeMillis(),
+    val isPinned: Boolean = false
+) {
+    fun toNote(): Note {
+        val gson = Gson()
+        val attachments: List<com.appship.reference.data.NoteAttachment> = 
+            gson.fromJson(attachmentsJson, object : TypeToken<List<com.appship.reference.data.NoteAttachment>>() {}.type) ?: emptyList()
+        val tags: List<String> = gson.fromJson(tagsJson, object : TypeToken<List<String>>() {}.type) ?: emptyList()
+        
+        return Note(
+            id = id,
+            title = title,
+            content = content,
+            attachments = attachments,
+            tags = tags,
+            createdAt = java.util.Date(createdAtMillis),
+            updatedAt = java.util.Date(updatedAtMillis),
+            isPinned = isPinned
+        )
+    }
+
+    companion object {
+        fun fromNote(note: Note): NoteEntity {
+            val gson = Gson()
+            return NoteEntity(
+                id = note.id,
+                title = note.title,
+                content = note.content,
+                attachmentsJson = gson.toJson(note.attachments),
+                tagsJson = gson.toJson(note.tags),
+                createdAtMillis = note.createdAt.time,
+                updatedAtMillis = note.updatedAt.time,
+                isPinned = note.isPinned
+            )
+        }
+    }
+}