@shaykec/app-agent 1.0.4 → 1.0.6

package/templates/android/TaskTemplate/app/src/main/kotlin/com/appship/task/TaskApplication.kt

@@ -1,9 +1,11 @@
 package com.appship.task
 
 import android.app.Application
+import com.appship.task.data.local.LocalStorageProvider
 
 class TaskApplication : Application() {
     override fun onCreate() {
         super.onCreate()
+        LocalStorageProvider.initialize(this)
     }
 }

package/templates/android/TaskTemplate/app/src/main/kotlin/com/appship/task/core/components/EmptyStateView.kt

@@ -0,0 +1,137 @@
+package com.appship.task.core.components
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+
+/**
+ * Reusable empty state view with illustration, title, subtitle, and optional CTA button.
+ * Used when a list or screen has no content to display.
+ */
+@Composable
+fun EmptyStateView(
+    config: EmptyStateConfig,
+    modifier: Modifier = Modifier
+) {
+    Column(
+        modifier = modifier
+            .fillMaxSize()
+            .padding(24.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Center
+    ) {
+        // Icon/Illustration
+        if (config.icon != null) {
+            Icon(
+                imageVector = config.icon,
+                contentDescription = null,
+                modifier = Modifier
+                    .size(64.dp)
+                    .testTag("empty_state_icon"),
+                tint = config.iconColor ?: MaterialTheme.colorScheme.primary
+            )
+            Spacer(modifier = Modifier.height(16.dp))
+        }
+
+        // Title
+        Text(
+            text = config.title,
+            style = MaterialTheme.typography.titleLarge,
+            textAlign = TextAlign.Center,
+            modifier = Modifier.testTag("empty_state_title")
+        )
+
+        // Subtitle
+        if (config.subtitle != null) {
+            Spacer(modifier = Modifier.height(8.dp))
+            Text(
+                text = config.subtitle,
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                textAlign = TextAlign.Center,
+                modifier = Modifier.testTag("empty_state_subtitle")
+            )
+        }
+
+        // CTA Button
+        if (config.buttonTitle != null && config.buttonAction != null) {
+            Spacer(modifier = Modifier.height(24.dp))
+            Button(
+                onClick = { config.buttonAction?.invoke() },
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .testTag("empty_state_button")
+            ) {
+                Text(config.buttonTitle!!)
+            }
+        }
+    }
+}
+
+/**
+ * Configuration for empty state view.
+ */
+data class EmptyStateConfig(
+    val title: String,
+    val subtitle: String? = null,
+    val icon: ImageVector? = null,
+    val iconColor: Color? = null,
+    val buttonTitle: String? = null,
+    val buttonAction: (() -> Unit)? = null
+)
+
+/**
+ * Preset empty state configurations.
+ */
+object EmptyStatePresets {
+    fun noResults(searchQuery: String? = null): EmptyStateConfig {
+        return EmptyStateConfig(
+            title = "No Results Found",
+            subtitle = searchQuery?.let { "We couldn't find anything matching \"$it\"" },
+            icon = Icons.Filled.Search,
+            iconColor = null
+        )
+    }
+
+    fun noItems(
+        message: String? = null,
+        onAdd: (() -> Unit)? = null
+    ): EmptyStateConfig {
+        return EmptyStateConfig(
+            title = "Nothing Here Yet",
+            subtitle = message ?: "Get started by adding your first item",
+            icon = Icons.Filled.Inbox,
+            buttonTitle = if (onAdd != null) "Add Item" else null,
+            buttonAction = onAdd
+        )
+    }
+
+    fun noFavorites(onBrowse: (() -> Unit)? = null): EmptyStateConfig {
+        return EmptyStateConfig(
+            title = "No Favorites Yet",
+            subtitle = "Items you favorite will appear here",
+            icon = Icons.Filled.FavoriteBorder,
+            buttonTitle = if (onBrowse != null) "Browse" else null,
+            buttonAction = onBrowse
+        )
+    }
+
+    fun noConnection(onRetry: () -> Unit): EmptyStateConfig {
+        return EmptyStateConfig(
+            title = "No Internet Connection",
+            subtitle = "Please check your connection and try again",
+            icon = Icons.Filled.WifiOff,
+            buttonTitle = "Retry",
+            buttonAction = onRetry
+        )
+    }
+}

package/templates/android/TaskTemplate/app/src/main/kotlin/com/appship/task/data/DataRepository.kt

@@ -0,0 +1,41 @@
+package com.appship.task.data
+
+import kotlinx.coroutines.flow.StateFlow
+import java.time.LocalDate
+
+/**
+ * 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.
+ * Use [DataSourceResolver.repository] to get the active provider.
+ */
+interface DataRepository {
+    // Observable state
+    val tasks: StateFlow<List<Task>>
+    val projects: StateFlow<List<Project>>
+    val tags: StateFlow<List<Tag>>
+    val kanbanColumns: StateFlow<List<KanbanColumn>>
+
+    // Task operations
+    fun getTasks(): List<Task>
+    fun getTask(id: String): Task?
+    fun createTask(task: Task)
+    fun updateTask(task: Task)
+    fun deleteTask(id: String)
+
+    // Project operations
+    fun getProjects(): List<Project>
+    fun getProject(id: String): Project?
+
+    // Query operations
+    fun getTasksByTag(tagId: String): List<Task>
+    fun getTasksByDueDate(date: LocalDate): List<Task>
+
+    // Kanban operations
+    fun getKanbanColumns(): List<KanbanColumn>
+    fun moveTaskToColumn(taskId: String, columnId: String)
+    
+    // Data loading (for LocalStorageProvider)
+    fun loadData()
+}

package/templates/android/TaskTemplate/app/src/main/kotlin/com/appship/task/data/DataSourceResolver.kt

@@ -0,0 +1,22 @@
+package com.appship.task.data
+
+import com.appship.task.AppConfig
+import com.appship.task.mock.MockDataProvider
+
+/**
+ * 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 by repository.tasks.collectAsState()
+ */
+object DataSourceResolver {
+    val repository: DataRepository
+        get() = when (AppConfig.DataSource.active) {
+            AppConfig.DataSource.SourceType.LOCAL_STORAGE -> {
+                com.appship.task.data.local.LocalStorageProvider.getInstance()
+            }
+            AppConfig.DataSource.SourceType.MOCK -> MockDataProvider
+        }
+}

package/templates/android/TaskTemplate/app/src/main/kotlin/com/appship/task/data/local/AppDao.kt

@@ -0,0 +1,105 @@
+package com.appship.task.data.local
+
+import androidx.room.*
+
+/**
+ * Room DAO for all CRUD operations.
+ */
+@Dao
+interface AppDao {
+
+    // — Tasks —
+
+    @Query("SELECT * FROM tasks ORDER BY createdDate DESC")
+    suspend fun getAllTasks(): List<TaskEntity>
+
+    @Query("SELECT * FROM tasks WHERE id = :id LIMIT 1")
+    suspend fun getTaskById(id: String): TaskEntity?
+
+    @Query("SELECT * FROM tasks WHERE projectId = :projectId ORDER BY createdDate DESC")
+    suspend fun getTasksByProjectId(projectId: String): List<TaskEntity>
+
+    @Query("SELECT * FROM tasks WHERE tagsJson LIKE '%' || :tagId || '%' ORDER BY createdDate DESC")
+    suspend fun getTasksByTag(tagId: String): List<TaskEntity>
+
+    @Query("SELECT * FROM tasks WHERE dueDate = :dueDateEpochDay ORDER BY createdDate DESC")
+    suspend fun getTasksByDueDate(dueDateEpochDay: Long): List<TaskEntity>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertTask(task: TaskEntity)
+
+    @Update
+    suspend fun updateTask(task: TaskEntity)
+
+    @Delete
+    suspend fun deleteTask(task: TaskEntity)
+
+    @Query("SELECT COUNT(*) FROM tasks")
+    suspend fun taskCount(): Int
+
+    // — Projects —
+
+    @Query("SELECT * FROM projects ORDER BY sortOrder ASC")
+    suspend fun getAllProjects(): List<ProjectEntity>
+
+    @Query("SELECT * FROM projects WHERE id = :id LIMIT 1")
+    suspend fun getProjectById(id: String): ProjectEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertProject(project: ProjectEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertProjects(projects: List<ProjectEntity>)
+
+    @Update
+    suspend fun updateProject(project: ProjectEntity)
+
+    @Delete
+    suspend fun deleteProject(project: ProjectEntity)
+
+    @Query("SELECT COUNT(*) FROM projects")
+    suspend fun projectCount(): Int
+
+    // — Tags —
+
+    @Query("SELECT * FROM tags ORDER BY name ASC")
+    suspend fun getAllTags(): List<TagEntity>
+
+    @Query("SELECT * FROM tags WHERE id = :id LIMIT 1")
+    suspend fun getTagById(id: String): TagEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertTag(tag: TagEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertTags(tags: List<TagEntity>)
+
+    @Update
+    suspend fun updateTag(tag: TagEntity)
+
+    @Delete
+    suspend fun deleteTag(tag: TagEntity)
+
+    @Query("SELECT COUNT(*) FROM tags")
+    suspend fun tagCount(): Int
+
+    // — Kanban Columns —
+
+    @Query("SELECT * FROM kanban_columns ORDER BY sortOrder ASC")
+    suspend fun getAllKanbanColumns(): List<KanbanColumnEntity>
+
+    @Query("SELECT * FROM kanban_columns WHERE id = :id LIMIT 1")
+    suspend fun getKanbanColumnById(id: String): KanbanColumnEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertKanbanColumn(column: KanbanColumnEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertKanbanColumns(columns: List<KanbanColumnEntity>)
+
+    @Update
+    suspend fun updateKanbanColumn(column: KanbanColumnEntity)
+
+    @Delete
+    suspend fun deleteKanbanColumn(column: KanbanColumnEntity)
+}

package/templates/android/TaskTemplate/app/src/main/kotlin/com/appship/task/data/local/AppDatabase.kt

@@ -0,0 +1,39 @@
+package com.appship.task.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 = [
+        TaskEntity::class,
+        ProjectEntity::class,
+        TagEntity::class,
+        KanbanColumnEntity::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,
+                    "task_database"
+                ).build().also { INSTANCE = it }
+            }
+        }
+    }
+}

package/templates/android/TaskTemplate/app/src/main/kotlin/com/appship/task/data/local/KanbanColumnEntity.kt

@@ -0,0 +1,41 @@
+package com.appship.task.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.task.data.KanbanColumn
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+
+/**
+ * Room entity for KanbanColumn persistence.
+ */
+@Entity(tableName = "kanban_columns")
+data class KanbanColumnEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val taskIdsJson: String = "[]",
+    val sortOrder: Int = 0
+) {
+    fun toKanbanColumn(): KanbanColumn {
+        val gson = Gson()
+        val taskIds: List<String> = gson.fromJson(taskIdsJson, object : TypeToken<List<String>>() {}.type) ?: emptyList()
+        return KanbanColumn(
+            id = id,
+            title = title,
+            taskIds = taskIds,
+            sortOrder = sortOrder
+        )
+    }
+
+    companion object {
+        fun fromKanbanColumn(column: KanbanColumn): KanbanColumnEntity {
+            val gson = Gson()
+            return KanbanColumnEntity(
+                id = column.id,
+                title = column.title,
+                taskIdsJson = gson.toJson(column.taskIds),
+                sortOrder = column.sortOrder
+            )
+        }
+    }
+}

package/templates/android/TaskTemplate/app/src/main/kotlin/com/appship/task/data/local/LocalStorageProvider.kt

@@ -0,0 +1,204 @@
+package com.appship.task.data.local
+
+import android.content.Context
+import com.appship.task.data.*
+import com.appship.task.data.DataRepository
+import com.appship.task.mock.MockDataProvider
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import java.time.LocalDate
+
+/**
+ * Room-backed implementation of [DataRepository].
+ * Stores task management data 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 scope: CoroutineScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+) : DataRepository {
+
+    private val _tasks = MutableStateFlow<List<Task>>(emptyList())
+    override val tasks: StateFlow<List<Task>> = _tasks.asStateFlow()
+
+    private val _projects = MutableStateFlow<List<Project>>(emptyList())
+    override val projects: StateFlow<List<Project>> = _projects.asStateFlow()
+
+    private val _tags = MutableStateFlow<List<Tag>>(emptyList())
+    override val tags: StateFlow<List<Tag>> = _tags.asStateFlow()
+
+    private val _kanbanColumns = MutableStateFlow<List<KanbanColumn>>(emptyList())
+    override val kanbanColumns: StateFlow<List<KanbanColumn>> = _kanbanColumns.asStateFlow()
+
+    override fun loadData() {
+        scope.launch {
+            // Seed on first launch
+            if (dao.tagCount() == 0) {
+                seedDefaults()
+            }
+            refreshTags()
+            refreshProjects()
+            refreshTasks()
+            refreshKanbanColumns()
+        }
+    }
+
+    override fun getTasks(): List<Task> = _tasks.value
+
+    override fun getTask(id: String): Task? = _tasks.value.firstOrNull { it.id == id }
+
+    override fun createTask(task: Task) {
+        scope.launch {
+            dao.insertTask(TaskEntity.fromTask(task))
+            refreshTasks()
+            if (task.projectId != null) {
+                updateProjectTasks(projectId = task.projectId, taskId = task.id, add = true)
+            }
+        }
+    }
+
+    override fun updateTask(task: Task) {
+        scope.launch {
+            dao.updateTask(TaskEntity.fromTask(task))
+            refreshTasks()
+        }
+    }
+
+    override fun deleteTask(id: String) {
+        scope.launch {
+            val task = dao.getTaskById(id) ?: return@launch
+            val taskModel = task.toTask()
+            dao.deleteTask(task)
+            refreshTasks()
+            if (taskModel.projectId != null) {
+                updateProjectTasks(projectId = taskModel.projectId, taskId = id, add = false)
+            }
+            // Remove from kanban columns
+            val columns = dao.getAllKanbanColumns()
+            columns.forEach { col ->
+                val column = col.toKanbanColumn()
+                if (column.taskIds.contains(id)) {
+                    val updated = column.copy(taskIds = column.taskIds.filter { it != id })
+                    dao.updateKanbanColumn(KanbanColumnEntity.fromKanbanColumn(updated))
+                }
+            }
+            refreshKanbanColumns()
+        }
+    }
+
+    override fun getProjects(): List<Project> = _projects.value
+
+    override fun getProject(id: String): Project? = _projects.value.firstOrNull { it.id == id }
+
+    override fun getTasksByTag(tagId: String): List<Task> {
+        return _tasks.value.filter { it.tags.contains(tagId) }
+    }
+
+    override fun getTasksByDueDate(date: LocalDate): List<Task> {
+        return _tasks.value.filter { it.dueDate == date }
+    }
+
+    override fun getKanbanColumns(): List<KanbanColumn> = _kanbanColumns.value
+
+    override fun moveTaskToColumn(taskId: String, columnId: String) {
+        scope.launch {
+            // Remove from all columns
+            val columns = dao.getAllKanbanColumns()
+            columns.forEach { col ->
+                val column = col.toKanbanColumn()
+                if (column.taskIds.contains(taskId)) {
+                    val updated = column.copy(taskIds = column.taskIds.filter { it != taskId })
+                    dao.updateKanbanColumn(KanbanColumnEntity.fromKanbanColumn(updated))
+                }
+            }
+            // Add to target column
+            val targetCol = dao.getKanbanColumnById(columnId) ?: return@launch
+            val targetColumn = targetCol.toKanbanColumn()
+            val updated = targetColumn.copy(taskIds = targetColumn.taskIds + taskId)
+            dao.updateKanbanColumn(KanbanColumnEntity.fromKanbanColumn(updated))
+            refreshKanbanColumns()
+        }
+    }
+
+    // MARK: - Private helpers
+
+    private suspend fun refreshTasks() {
+        _tasks.value = dao.getAllTasks().map { it.toTask() }
+    }
+
+    private suspend fun refreshProjects() {
+        _projects.value = dao.getAllProjects().map { it.toProject() }
+    }
+
+    private suspend fun refreshTags() {
+        _tags.value = dao.getAllTags().map { it.toTag() }
+    }
+
+    private suspend fun refreshKanbanColumns() {
+        _kanbanColumns.value = dao.getAllKanbanColumns().map { it.toKanbanColumn() }
+    }
+
+    private suspend fun seedDefaults() {
+        // Seed tags
+        dao.insertTags(MockDataProvider.tags.value.map { TagEntity.fromTag(it) })
+
+        // Seed projects
+        dao.insertProjects(MockDataProvider.projects.value.map { ProjectEntity.fromProject(it) })
+
+        // Seed tasks
+        MockDataProvider.tasks.value.forEach { task ->
+            dao.insertTask(TaskEntity.fromTask(task))
+        }
+
+        // Seed kanban columns
+        dao.insertKanbanColumns(MockDataProvider.kanbanColumns.value.map { KanbanColumnEntity.fromKanbanColumn(it) })
+    }
+
+    private suspend fun updateProjectTasks(projectId: String, taskId: String, add: Boolean) {
+        val entity = dao.getProjectById(projectId) ?: return
+        var project = entity.toProject()
+        if (add) {
+            if (!project.tasks.contains(taskId)) {
+                project = project.copy(tasks = project.tasks + taskId)
+            }
+        } else {
+            project = project.copy(tasks = project.tasks.filter { it != taskId })
+        }
+        dao.updateProject(ProjectEntity.fromProject(project))
+        refreshProjects()
+    }
+
+    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)
+                        INSTANCE = LocalStorageProvider(db.appDao()).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/TaskTemplate/app/src/main/kotlin/com/appship/task/data/local/ProjectEntity.kt

@@ -0,0 +1,50 @@
+package com.appship.task.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.task.data.Project
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+
+/**
+ * Room entity for Project persistence.
+ */
+@Entity(tableName = "projects")
+data class ProjectEntity(
+    @PrimaryKey val id: String,
+    val name: String = "",
+    val description: String? = null,
+    val color: String = "#3B82F6",
+    val icon: String = "folder",
+    val sortOrder: Int = 0,
+    val tasksJson: String = "[]"
+) {
+    fun toProject(): Project {
+        val gson = Gson()
+        val tasks: List<String> = gson.fromJson(tasksJson, object : TypeToken<List<String>>() {}.type) ?: emptyList()
+        return Project(
+            id = id,
+            name = name,
+            description = description,
+            color = color,
+            icon = icon,
+            sortOrder = sortOrder,
+            tasks = tasks
+        )
+    }
+
+    companion object {
+        fun fromProject(project: Project): ProjectEntity {
+            val gson = Gson()
+            return ProjectEntity(
+                id = project.id,
+                name = project.name,
+                description = project.description,
+                color = project.color,
+                icon = project.icon,
+                sortOrder = project.sortOrder,
+                tasksJson = gson.toJson(project.tasks)
+            )
+        }
+    }
+}

package/templates/android/TaskTemplate/app/src/main/kotlin/com/appship/task/data/local/TagEntity.kt

@@ -0,0 +1,29 @@
+package com.appship.task.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.task.data.Tag
+
+/**
+ * Room entity for Tag persistence.
+ */
+@Entity(tableName = "tags")
+data class TagEntity(
+    @PrimaryKey val id: String,
+    val name: String = "",
+    val color: String = "#6B7280"
+) {
+    fun toTag(): Tag = Tag(
+        id = id,
+        name = name,
+        color = color
+    )
+
+    companion object {
+        fun fromTag(tag: Tag): TagEntity = TagEntity(
+            id = tag.id,
+            name = tag.name,
+            color = tag.color
+        )
+    }
+}