@shaykec/app-agent 1.0.4 → 1.0.6

package/templates/android/LearnTemplate/app/src/main/kotlin/com/appship/learn/data/local/AppDatabase.kt

@@ -0,0 +1,40 @@
+package com.appship.learn.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 learning domain entity tables.
+ */
+@Database(
+    entities = [
+        CourseEntity::class,
+        CategoryEntity::class,
+        FlashcardDeckEntity::class,
+        LeaderboardEntryEntity::class,
+        AchievementEntity::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,
+                    "learn_database"
+                ).build().also { INSTANCE = it }
+            }
+        }
+    }
+}

package/templates/android/LearnTemplate/app/src/main/kotlin/com/appship/learn/data/local/CategoryEntity.kt

@@ -0,0 +1,32 @@
+package com.appship.learn.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.learn.data.models.Category
+
+/**
+ * Room entity for Category persistence.
+ */
+@Entity(tableName = "categories")
+data class CategoryEntity(
+    @PrimaryKey val id: String,
+    val name: String = "",
+    val icon: String = "",
+    val courseCount: Int? = null
+) {
+    fun toCategory(): Category = Category(
+        id = id,
+        name = name,
+        icon = icon,
+        courseCount = courseCount
+    )
+
+    companion object {
+        fun fromCategory(category: Category): CategoryEntity = CategoryEntity(
+            id = category.id,
+            name = category.name,
+            icon = category.icon,
+            courseCount = category.courseCount
+        )
+    }
+}

package/templates/android/LearnTemplate/app/src/main/kotlin/com/appship/learn/data/local/CourseEntity.kt

@@ -0,0 +1,86 @@
+package com.appship.learn.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.learn.data.models.Category
+import com.appship.learn.data.models.Course
+import com.appship.learn.data.models.Difficulty
+import com.appship.learn.data.models.Lesson
+import com.google.gson.Gson
+
+/**
+ * Room entity for Course persistence.
+ */
+@Entity(tableName = "courses")
+data class CourseEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val description: String = "",
+    val categoryJSON: String = "{}",
+    val difficulty: String = "",
+    val thumbnailUrl: String = "",
+    val lessonsJSON: String = "[]",
+    val totalLessons: Int = 0,
+    val completedLessons: Int = 0,
+    val progress: Double = 0.0,
+    val instructor: String = "",
+    val rating: Double = 0.0,
+    val enrolledCount: Int = 0,
+    val duration: Int = 0,
+    val tagsJSON: String = "[]"
+) {
+    fun toCourse(): Course {
+        val category = try {
+            Gson().fromJson(categoryJSON, Category::class.java)
+        } catch (e: Exception) {
+            Category("unknown", "Unknown", "questionmark")
+        }
+        val lessons = try {
+            Gson().fromJson(lessonsJSON, Array<Lesson>::class.java).toList()
+        } catch (e: Exception) {
+            emptyList()
+        }
+        val tags = try {
+            Gson().fromJson(tagsJSON, Array<String>::class.java).toList()
+        } catch (e: Exception) {
+            emptyList()
+        }
+        return Course(
+            id = id,
+            title = title,
+            description = description,
+            category = category,
+            difficulty = Difficulty.values().find { it.name == difficulty } ?: Difficulty.BEGINNER,
+            thumbnailUrl = thumbnailUrl,
+            lessons = lessons,
+            totalLessons = totalLessons,
+            completedLessons = completedLessons,
+            progress = progress,
+            instructor = instructor,
+            rating = rating,
+            enrolledCount = enrolledCount,
+            duration = duration,
+            tags = tags
+        )
+    }
+
+    companion object {
+        fun fromCourse(course: Course): CourseEntity = CourseEntity(
+            id = course.id,
+            title = course.title,
+            description = course.description,
+            categoryJSON = Gson().toJson(course.category),
+            difficulty = course.difficulty.name,
+            thumbnailUrl = course.thumbnailUrl,
+            lessonsJSON = Gson().toJson(course.lessons),
+            totalLessons = course.totalLessons,
+            completedLessons = course.completedLessons,
+            progress = course.progress,
+            instructor = course.instructor,
+            rating = course.rating,
+            enrolledCount = course.enrolledCount,
+            duration = course.duration,
+            tagsJSON = Gson().toJson(course.tags)
+        )
+    }
+}

package/templates/android/LearnTemplate/app/src/main/kotlin/com/appship/learn/data/local/FlashcardDeckEntity.kt

@@ -0,0 +1,50 @@
+package com.appship.learn.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.learn.data.models.Category
+import com.appship.learn.data.models.Flashcard
+import com.appship.learn.data.models.FlashcardDeck
+import com.google.gson.Gson
+
+/**
+ * Room entity for FlashcardDeck persistence.
+ */
+@Entity(tableName = "flashcard_decks")
+data class FlashcardDeckEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val categoryJSON: String = "{}",
+    val cardsJSON: String = "[]",
+    val mastery: Double = 0.0
+) {
+    fun toFlashcardDeck(): FlashcardDeck {
+        val category = try {
+            Gson().fromJson(categoryJSON, Category::class.java)
+        } catch (e: Exception) {
+            Category("unknown", "Unknown", "questionmark")
+        }
+        val cards = try {
+            Gson().fromJson(cardsJSON, Array<Flashcard>::class.java).toList()
+        } catch (e: Exception) {
+            emptyList()
+        }
+        return FlashcardDeck(
+            id = id,
+            title = title,
+            category = category,
+            cards = cards,
+            mastery = mastery
+        )
+    }
+
+    companion object {
+        fun fromFlashcardDeck(deck: FlashcardDeck): FlashcardDeckEntity = FlashcardDeckEntity(
+            id = deck.id,
+            title = deck.title,
+            categoryJSON = Gson().toJson(deck.category),
+            cardsJSON = Gson().toJson(deck.cards),
+            mastery = deck.mastery
+        )
+    }
+}

package/templates/android/LearnTemplate/app/src/main/kotlin/com/appship/learn/data/local/LeaderboardEntryEntity.kt

@@ -0,0 +1,41 @@
+package com.appship.learn.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.learn.data.models.LeaderboardEntry
+
+/**
+ * Room entity for LeaderboardEntry persistence.
+ */
+@Entity(tableName = "leaderboard_entries")
+data class LeaderboardEntryEntity(
+    @PrimaryKey val id: String,
+    val userId: String = "",
+    val displayName: String = "",
+    val avatarUrl: String? = null,
+    val xp: Int = 0,
+    val rank: Int = 0,
+    val streak: Int = 0
+) {
+    fun toLeaderboardEntry(): LeaderboardEntry = LeaderboardEntry(
+        id = id,
+        userId = userId,
+        displayName = displayName,
+        avatarUrl = avatarUrl,
+        xp = xp,
+        rank = rank,
+        streak = streak
+    )
+
+    companion object {
+        fun fromLeaderboardEntry(entry: LeaderboardEntry): LeaderboardEntryEntity = LeaderboardEntryEntity(
+            id = entry.id,
+            userId = entry.userId,
+            displayName = entry.displayName,
+            avatarUrl = entry.avatarUrl,
+            xp = entry.xp,
+            rank = entry.rank,
+            streak = entry.streak
+        )
+    }
+}

package/templates/android/LearnTemplate/app/src/main/kotlin/com/appship/learn/data/local/LocalStorageProvider.kt

@@ -0,0 +1,288 @@
+package com.appship.learn.data.local
+
+import android.content.Context
+import android.content.SharedPreferences
+import com.appship.learn.AppConfig
+import com.appship.learn.data.DataRepository
+import com.appship.learn.data.models.*
+import com.appship.learn.mock.MockDataProvider
+import com.google.gson.Gson
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * Room-backed implementation of [DataRepository].
+ * Stores learning 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 prefs: SharedPreferences,
+    private val scope: CoroutineScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+) : DataRepository {
+
+    // Observable state
+    private val _courses = MutableStateFlow<List<Course>>(emptyList())
+    override val courses: StateFlow<List<Course>> = _courses.asStateFlow()
+
+    private val _categories = MutableStateFlow<List<Category>>(emptyList())
+    override val categories: StateFlow<List<Category>> = _categories.asStateFlow()
+
+    private val _flashcardDecks = MutableStateFlow<List<FlashcardDeck>>(emptyList())
+    override val flashcardDecks: StateFlow<List<FlashcardDeck>> = _flashcardDecks.asStateFlow()
+
+    private val _leaderboardEntries = MutableStateFlow<List<LeaderboardEntry>>(emptyList())
+    override val leaderboardEntries: StateFlow<List<LeaderboardEntry>> = _leaderboardEntries.asStateFlow()
+
+    private val _achievements = MutableStateFlow<List<Achievement>>(emptyList())
+    override val achievements: StateFlow<List<Achievement>> = _achievements.asStateFlow()
+
+    private val _userProgress = MutableStateFlow<UserProgress>(loadUserProgress())
+    override val userProgress: StateFlow<UserProgress> = _userProgress.asStateFlow()
+
+    init {
+        scope.launch {
+            // Seed data on first launch
+            if (dao.courseCount() == 0) {
+                seedDefaultData()
+            }
+            loadData()
+        }
+    }
+
+    private suspend fun loadData() {
+        _courses.value = dao.getAllCourses().map { it.toCourse() }
+        _categories.value = dao.getAllCategories().map { it.toCategory() }
+        _flashcardDecks.value = dao.getAllFlashcardDecks().map { it.toFlashcardDeck() }
+        _leaderboardEntries.value = dao.getAllLeaderboardEntries().map { it.toLeaderboardEntry() }
+        _achievements.value = dao.getAllAchievements().map { it.toAchievement() }
+        _userProgress.value = loadUserProgress()
+    }
+
+    private suspend fun seedDefaultData() {
+        // Seed categories
+        MockDataProvider.categories.value.forEach {
+            dao.insertCategory(CategoryEntity.fromCategory(it))
+        }
+
+        // Seed courses
+        MockDataProvider.getCourses().forEach {
+            dao.insertCourse(CourseEntity.fromCourse(it))
+        }
+
+        // Seed flashcard decks
+        MockDataProvider.getFlashcardDecks().forEach {
+            dao.insertFlashcardDeck(FlashcardDeckEntity.fromFlashcardDeck(it))
+        }
+
+        // Seed leaderboard entries
+        MockDataProvider.getLeaderboard().forEach {
+            dao.insertLeaderboardEntry(LeaderboardEntryEntity.fromLeaderboardEntry(it))
+        }
+
+        // Seed achievements
+        MockDataProvider.achievements.value.forEach {
+            dao.insertAchievement(AchievementEntity.fromAchievement(it))
+        }
+
+        // Seed user progress (stored in SharedPreferences)
+        saveUserProgress(MockDataProvider.getProgress())
+    }
+
+    // Course operations
+    override fun getCourses(): List<Course> = _courses.value
+
+    override fun getCourse(id: String): Course? = _courses.value.firstOrNull { it.id == id }
+
+    override fun getLessons(courseId: String): List<Lesson> {
+        return getCourse(courseId)?.lessons ?: emptyList()
+    }
+
+    // Quiz operations
+    override fun getQuiz(lessonId: String): Quiz? {
+        // Find lesson's course and generate quiz (same as MockDataProvider)
+        for (course in _courses.value) {
+            if (course.lessons.any { it.id == lessonId }) {
+                // Generate quiz similar to MockDataProvider
+                return Quiz(
+                    id = "quiz-$lessonId",
+                    lessonId = lessonId,
+                    title = "Quiz: Lesson $lessonId",
+                    questions = emptyList(), // Simplified - would generate from MockDataProvider
+                    passingScore = AppConfig.Business.PASSING_SCORE
+                )
+            }
+        }
+        return null
+    }
+
+    override fun submitQuizScore(lessonId: String, score: Double, timeSpent: Int) {
+        scope.launch {
+            val progress = _userProgress.value
+            val updated = progress.copy(
+                totalXP = progress.totalXP + AppConfig.Business.XP_PER_QUIZ,
+                completedLessons = progress.completedLessons + 1,
+                averageQuizScore = (progress.averageQuizScore * progress.completedLessons + score) / (progress.completedLessons + 1),
+                level = (progress.totalXP + AppConfig.Business.XP_PER_QUIZ) / AppConfig.Business.LEVEL_UP_THRESHOLD
+            )
+            saveUserProgress(updated)
+            _userProgress.value = updated
+        }
+    }
+
+    // Flashcard operations
+    override fun getFlashcardDecks(): List<FlashcardDeck> = _flashcardDecks.value
+
+    override fun updateFlashcard(deckId: String, cardId: String, difficulty: FlashcardDifficulty) {
+        scope.launch {
+            val deckEntity = dao.getFlashcardDeckById(deckId) ?: return@launch
+            val deck = deckEntity.toFlashcardDeck()
+            val cardIndex = deck.cards.indexOfFirst { it.id == cardId }
+            if (cardIndex >= 0) {
+                val updatedCards = deck.cards.toMutableList()
+                val card = updatedCards[cardIndex]
+                val daysUntilReview = when (difficulty) {
+                    FlashcardDifficulty.EASY -> 7
+                    FlashcardDifficulty.MEDIUM -> 3
+                    FlashcardDifficulty.HARD -> 1
+                }
+                updatedCards[cardIndex] = card.copy(
+                    difficulty = difficulty,
+                    repetitions = card.repetitions + 1,
+                    nextReviewDate = System.currentTimeMillis() + (daysUntilReview * 86400000L)
+                )
+                val masteredCount = updatedCards.count { it.difficulty == FlashcardDifficulty.EASY && it.repetitions >= 3 }
+                val updatedDeck = deck.copy(
+                    cards = updatedCards,
+                    mastery = masteredCount.toDouble() / updatedCards.size
+                )
+                dao.updateFlashcardDeck(FlashcardDeckEntity.fromFlashcardDeck(updatedDeck))
+                loadData()
+            }
+        }
+    }
+
+    // Progress operations
+    override fun getProgress(): UserProgress = _userProgress.value
+
+    override fun updateProgress(progress: UserProgress) {
+        scope.launch {
+            saveUserProgress(progress)
+            _userProgress.value = progress
+        }
+    }
+
+    override fun markLessonComplete(courseId: String, lessonId: String) {
+        scope.launch {
+            val courseEntity = dao.getCourseById(courseId) ?: return@launch
+            val course = courseEntity.toCourse()
+            val lessonIndex = course.lessons.indexOfFirst { it.id == lessonId }
+            if (lessonIndex >= 0) {
+                val updatedLessons = course.lessons.toMutableList()
+                updatedLessons[lessonIndex] = updatedLessons[lessonIndex].copy(isCompleted = true)
+                val updatedCourse = course.copy(
+                    lessons = updatedLessons,
+                    completedLessons = course.completedLessons + 1,
+                    progress = (course.completedLessons + 1).toDouble() / course.totalLessons
+                )
+                dao.updateCourse(CourseEntity.fromCourse(updatedCourse))
+                loadData()
+
+                // Update user progress
+                val progress = _userProgress.value
+                val updated = progress.copy(
+                    totalXP = progress.totalXP + AppConfig.Business.XP_PER_LESSON,
+                    completedLessons = progress.completedLessons + 1,
+                    level = (progress.totalXP + AppConfig.Business.XP_PER_LESSON) / AppConfig.Business.LEVEL_UP_THRESHOLD
+                )
+                if (updatedCourse.progress >= 1.0) {
+                    updated.copy(completedCourses = updated.completedCourses + 1)
+                }
+                updateProgress(updated)
+            }
+        }
+    }
+
+    override fun updateStreak() {
+        scope.launch {
+            val progress = _userProgress.value
+            val updated = progress.copy(
+                currentStreak = progress.currentStreak + 1,
+                longestStreak = maxOf(progress.currentStreak + 1, progress.longestStreak),
+                totalXP = progress.totalXP + AppConfig.Business.XP_PER_STREAK
+            )
+            updateProgress(updated)
+        }
+    }
+
+    // Leaderboard operations
+    override fun getLeaderboard(): List<LeaderboardEntry> = _leaderboardEntries.value.sortedBy { it.rank }
+
+    // Achievement operations
+    override fun unlockAchievement(achievementId: String) {
+        scope.launch {
+            val entity = dao.getAchievementById(achievementId) ?: return@launch
+            val updated = entity.copy(isUnlocked = true, unlockedDate = System.currentTimeMillis())
+            dao.updateAchievement(updated)
+            loadData()
+        }
+    }
+
+    // Reset
+    override fun reset() {
+        scope.launch {
+            // Clear all data and reseed
+            // Note: Room doesn't have a simple "delete all" - would need individual deletes or drop/recreate
+            seedDefaultData()
+            loadData()
+            saveUserProgress(MockDataProvider.getProgress())
+        }
+    }
+
+    // User Progress helpers
+    private fun loadUserProgress(): UserProgress {
+        val json = prefs.getString("userProgress", null) ?: return MockDataProvider.getProgress()
+        return try {
+            Gson().fromJson(json, UserProgress::class.java)
+        } catch (e: Exception) {
+            MockDataProvider.getProgress()
+        }
+    }
+
+    private fun saveUserProgress(progress: UserProgress) {
+        prefs.edit().putString("userProgress", Gson().toJson(progress)).apply()
+    }
+
+    companion object {
+        @Volatile
+        private var INSTANCE: LocalStorageProvider? = null
+
+        /**
+         * Initialize with Android context. Call from Application.onCreate() or MainActivity.onCreate().
+         */
+        fun initialize(context: Context) {
+            if (INSTANCE == null) {
+                synchronized(this) {
+                    if (INSTANCE == null) {
+                        val db = AppDatabase.getInstance(context)
+                        val prefs = context.getSharedPreferences("learn_prefs", Context.MODE_PRIVATE)
+                        INSTANCE = LocalStorageProvider(db.appDao(), prefs)
+                    }
+                }
+            }
+        }
+
+        /**
+         * 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/LearnTemplate/app/src/main/kotlin/com/appship/learn/features/courses/CourseListScreen.kt

@@ -8,14 +8,17 @@ import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
 import androidx.navigation.NavController
-import com.appship.learn.mock.MockDataProvider
+import com.appship.learn.data.DataSourceResolver
+import com.appship.learn.core.components.EmptyStateView
+import com.appship.learn.core.components.EmptyStatePresets
 import com.appship.learn.data.models.Course
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun CourseListScreen(navController: NavController) {
-    val courses by MockDataProvider.courses.collectAsState()
-    val categories by MockDataProvider.categories.collectAsState()
+    val repository = remember { DataSourceResolver.repository }
+    val courses by repository.courses.collectAsState()
+    val categories by repository.categories.collectAsState()
     var searchText by remember { mutableStateOf("") }
     
     Scaffold(
@@ -46,10 +49,18 @@ fun CourseListScreen(navController: NavController) {
                 }
             }
             
-            items(courses.size) { index ->
-                CourseCard(course = courses[index], onClick = {
-                    // Navigate to course detail
-                })
+            if (courses.isEmpty()) {
+                item {
+                    EmptyStateView(
+                        config = EmptyStatePresets.noItems(message = "No courses available yet.")
+                    )
+                }
+            } else {
+                items(courses.size) { index ->
+                    CourseCard(course = courses[index], onClick = {
+                        // Navigate to course detail
+                    })
+                }
             }
         }
     }

package/templates/android/LearnTemplate/app/src/main/kotlin/com/appship/learn/features/leaderboard/LeaderboardScreen.kt

@@ -7,14 +7,17 @@ import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
+import com.appship.learn.data.DataSourceResolver
+import com.appship.learn.core.components.EmptyStateView
+import com.appship.learn.core.components.EmptyStatePresets
 import com.appship.learn.data.models.formatXP
 import com.appship.learn.data.models.formatStreak
-import com.appship.learn.mock.MockDataProvider
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun LeaderboardScreen() {
-    val entries by MockDataProvider.leaderboardEntries.collectAsState()
+    val repository = remember { DataSourceResolver.repository }
+    val entries by repository.leaderboardEntries.collectAsState()
     
     Scaffold(
         topBar = { TopAppBar(title = { Text("Leaderboard") }) }

package/templates/android/LearnTemplate/app/src/main/kotlin/com/appship/learn/features/profile/ProfileScreen.kt

@@ -10,14 +10,15 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.MenuBook
 import androidx.compose.material.icons.filled.Settings
 import androidx.compose.material.icons.filled.TrendingUp
+import com.appship.learn.data.DataSourceResolver
 import com.appship.learn.data.models.formatXP
 import com.appship.learn.data.models.formatStreak
-import com.appship.learn.mock.MockDataProvider
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun ProfileScreen(navController: NavController) {
-    val progress by MockDataProvider.userProgress.collectAsState()
+    val repository = remember { DataSourceResolver.repository }
+    val progress by repository.userProgress.collectAsState()
     
     Scaffold(
         topBar = { TopAppBar(title = { Text("Profile") }) }

package/templates/android/LearnTemplate/app/src/main/kotlin/com/appship/learn/features/progress/ProgressDashboardScreen.kt

@@ -6,14 +6,15 @@ import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
+import com.appship.learn.data.DataSourceResolver
 import com.appship.learn.data.models.formatXP
 import com.appship.learn.data.models.formatStreak
-import com.appship.learn.mock.MockDataProvider
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun ProgressDashboardScreen() {
-    val progress by MockDataProvider.userProgress.collectAsState()
+    val repository = remember { DataSourceResolver.repository }
+    val progress by repository.userProgress.collectAsState()
     
     Scaffold(
         topBar = { TopAppBar(title = { Text("Progress") }) }