CheckPoint save for adding 'Tour' screen, and PhotoData and PhotoViewModels

.idea/.name

@@ -1 +0,0 @@
-SherpAI2

.kotlin/errors/errors-1766244784240.log

@@ -1,4 +0,0 @@
-kotlin version: 2.0.21
-error message: The daemon has terminated unexpectedly on startup attempt #1 with error code: 0. The daemon process output:
-    1. Kotlin compile daemon is ready
-

app/build.gradle.kts

@@ -1,75 +1,77 @@
+// build.gradle.kts (Module: :app)
+
 plugins {
-    alias(libs.plugins.android.application)
+    // 1. Core Android and Kotlin plugins (MUST be first)
-    alias(libs.plugins.kotlin.android)
+    id("com.android.application")
-    alias(libs.plugins.kotlin.compose)
+    kotlin("android")
-    alias(libs.plugins.ksp)
+
-    alias(libs.plugins.hilt.android)
+    id("org.jetbrains.kotlin.plugin.compose") // Note: No version is specified here
 }
 
 android {
+    // 2. Android Configuration
     namespace = "com.placeholder.sherpai2"
-    compileSdk = 35
+    compileSdk = 34
 
     defaultConfig {
         applicationId = "com.placeholder.sherpai2"
-        minSdk = 25
+        minSdk = 24
-        targetSdk = 35
+        targetSdk = 34
         versionCode = 1
         versionName = "1.0"
-
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
-    buildTypes {
+    // 3. Kotlin & Java Settings
-        release {
-            isMinifyEnabled = false
-            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
-        }
-    }
-
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_11
+        sourceCompatibility = JavaVersion.VERSION_1_8
-        targetCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_1_8
     }
-
     kotlinOptions {
-        jvmTarget = "11"
+        jvmTarget = "1.8"
     }
 
+    // 4. Jetpack Compose Configuration (Crucial!)
     buildFeatures {
         compose = true
     }
+
+    composeOptions {
+        kotlinCompilerExtensionVersion = "1.5.8" // Must match your Kotlin version
+    }
 }
 
 dependencies {
-    // Core & Lifecycle
+    // --- CORE ANDROID & LIFECYCLE ---
-    implementation(libs.androidx.core.ktx)
+    implementation("androidx.core:core-ktx:1.12.0")
-    implementation(libs.androidx.lifecycle.runtime.ktx)
+    implementation("androidx.lifecycle:lifecycle-runtime-compose:2.7.0")
-    implementation(libs.androidx.lifecycle.viewmodel.compose)
+    implementation("androidx.activity:activity-compose:1.8.2") // Fixes 'activity' ref error
-    implementation(libs.androidx.activity.compose)
 
-    // Compose
+    // --- JETPACK COMPOSE UI (Material 3) ---
-    implementation(platform(libs.androidx.compose.bom))
+    implementation("androidx.compose.ui:ui")
-    implementation(libs.androidx.compose.ui)
+    implementation("androidx.compose.ui:ui-graphics")
-    implementation(libs.androidx.compose.ui.graphics)
+    implementation("androidx.compose.ui:ui-tooling-preview")
-    implementation(libs.androidx.compose.ui.tooling.preview)
+    implementation("androidx.compose.material3:material3") // Fixes 'material3' ref error
-    implementation(libs.androidx.compose.material3)
-    implementation(libs.androidx.compose.material.icons)
-    debugImplementation(libs.androidx.compose.ui.tooling)
 
-    // Hilt DI
+    // --- COMPOSE ICONS (Fixes 'material' and 'Icons' ref errors) ---
-    implementation(libs.hilt.android)
+    // Uses direct string to avoid Version Catalog conflicts
-    ksp(libs.hilt.compiler)
+    implementation("androidx.compose.material:material-icons-extended:1.6.0")
-    implementation(libs.androidx.hilt.navigation.compose)
 
-    // Navigation
+    // --- STATE MANAGEMENT / COROUTINES ---
-    implementation(libs.androidx.navigation.compose)
+    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.7.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
 
-    // Room Database
+    // --- TESTING ---
-    implementation(libs.room.runtime)
+    testImplementation("junit:junit:4.13.2")
-    implementation(libs.room.ktx)
+    androidTestImplementation("androidx.test.ext:junit:1.1.5")
-    ksp(libs.room.compiler)
+    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
+    androidTestImplementation("androidx.compose.ui:ui-test-junit4")
+    debugImplementation("androidx.compose.ui:ui-tooling")
+    debugImplementation("androidx.compose.ui:ui-test-manifest")
 
-    // Coil Images
+    implementation("androidx.compose.foundation:foundation:1.6.0") // Use your current Compose version
-    implementation(libs.coil.compose)
+    implementation("androidx.compose.material3:material3:1.2.1") // <-- Fix/Reconfirm Material 3
+
+    implementation("io.coil-kt:coil-compose:2.6.0")
 }

app/src/main/AndroidManifest.xml

@@ -10,8 +10,7 @@
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:theme="@style/Theme.SherpAI2"
+        android:theme="@style/Theme.SherpAI2">
-        android:name=".SherpAIApplication">
         <activity
             android:name=".MainActivity"
             android:exported="true"
@@ -24,6 +23,5 @@
             </intent-filter>
         </activity>
     </application>
-    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
+
-    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
 </manifest>

app/src/main/java/com/placeholder/sherpai2/MainActivity.kt

@@ -1,123 +1,30 @@
 package com.placeholder.sherpai2
 
-import android.Manifest
-import android.content.pm.PackageManager
-import android.os.Build
 import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.material3.Text
+import androidx.compose.material3.MaterialTheme
-import androidx.compose.runtime.*
+import androidx.compose.material3.Surface
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.core.content.ContextCompat
+import com.placeholder.sherpai2.presentation.MainScreen // IMPORT your main screen
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.navigation.NavType
-import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.composable
-import androidx.navigation.compose.rememberNavController
-import androidx.navigation.navArgument
-import com.placeholder.sherpai2.ui.imagedetail.ImageDetailScreen
-import com.placeholder.sherpai2.ui.imagedetail.viewmodel.ImageDetailViewModel
-import com.placeholder.sherpai2.ui.search.SearchScreen
-import com.placeholder.sherpai2.ui.search.SearchViewModel
-import com.placeholder.sherpai2.ui.theme.SherpAI2Theme
-import dagger.hilt.android.AndroidEntryPoint
 
-/**
- * Centralized string-based navigation routes.
- */
-object Routes {
-    const val Search = "search"
-    const val ImageDetail = "image_detail"
-}
-
-@AndroidEntryPoint
 class MainActivity : ComponentActivity() {
-
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-
-        val mediaPermission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            Manifest.permission.READ_MEDIA_IMAGES
-        } else {
-            Manifest.permission.READ_EXTERNAL_STORAGE
-        }
-
         setContent {
-            SherpAI2Theme {
+            // Assume you have a Theme file named SherpAI2Theme (standard for new projects)
-                var hasPermission by remember {
+            // Replace with your actual project theme if different
-                    mutableStateOf(
+            MaterialTheme {
-                        ContextCompat.checkSelfPermission(this, mediaPermission) ==
+                Surface(
-                                PackageManager.PERMISSION_GRANTED
-                    )
-                }
-
-                val permissionLauncher = rememberLauncherForActivityResult(
-                    ActivityResultContracts.RequestPermission()
-                ) { granted -> hasPermission = granted }
-
-                LaunchedEffect(Unit) {
-                    if (!hasPermission) permissionLauncher.launch(mediaPermission)
-                }
-
-                if (hasPermission) {
-                    AppNavigation()
-                } else {
-                    PermissionDeniedScreen()
-                }
-            }
-        }
-    }
-}
-
-@Composable
-fun AppNavigation() {
-    val navController = rememberNavController()
-
-    NavHost(
-        navController = navController,
-        startDestination = Routes.Search
-    ) {
-
-        // Search screen
-        composable(Routes.Search) {
-            val searchViewModel: SearchViewModel = hiltViewModel()
-
-            SearchScreen(
-                searchViewModel = searchViewModel,
-                onImageClick = { imageId ->
-                    navController.navigate("${Routes.ImageDetail}/$imageId")
-                }
-            )
-        }
-
-        // Image detail screen
-        composable(
-            route = "${Routes.ImageDetail}/{imageId}",
-            arguments = listOf(navArgument("imageId") { type = NavType.StringType })
-        ) { backStackEntry ->
-            val imageId = backStackEntry.arguments?.getString("imageId") ?: ""
-            val detailViewModel: ImageDetailViewModel = hiltViewModel()
-
-            ImageDetailScreen(
-                imageUri = imageId,
-                onBack = { navController.popBackStack() }
-            )
-        }
-    }
-}
-
-@Composable
-private fun PermissionDeniedScreen() {
-    Box(
                     modifier = Modifier.fillMaxSize(),
-        contentAlignment = Alignment.Center
+                    color = MaterialTheme.colorScheme.background
                 ) {
-        Text("Please grant photo access to use the app.")
+                    // Launch the main navigation UI
+                    MainScreen()
+                }
+            }
+        }
     }
 }
+

app/src/main/java/com/placeholder/sherpai2/SherpAIApplication.kt

@@ -1,7 +0,0 @@
-package com.placeholder.sherpai2
-
-import android.app.Application
-import dagger.hilt.android.HiltAndroidApp
-
-@HiltAndroidApp
-class SherpAIApplication : Application()

app/src/main/java/com/placeholder/sherpai2/data/local/AppDatabase.kt

@@ -1,47 +0,0 @@
-package com.placeholder.sherpai2.data.local
-
-import androidx.room.Database
-import androidx.room.RoomDatabase
-import com.placeholder.sherpai2.data.local.dao.EventDao
-import com.placeholder.sherpai2.data.local.dao.ImageAggregateDao
-import com.placeholder.sherpai2.data.local.dao.ImageDao
-import com.placeholder.sherpai2.data.local.dao.ImageEventDao
-import com.placeholder.sherpai2.data.local.dao.ImagePersonDao
-import com.placeholder.sherpai2.data.local.dao.ImageTagDao
-import com.placeholder.sherpai2.data.local.dao.PersonDao
-import com.placeholder.sherpai2.data.local.dao.TagDao
-import com.placeholder.sherpai2.data.local.entity.EventEntity
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-import com.placeholder.sherpai2.data.local.entity.ImageEventEntity
-import com.placeholder.sherpai2.data.local.entity.ImagePersonEntity
-import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
-import com.placeholder.sherpai2.data.local.entity.PersonEntity
-import com.placeholder.sherpai2.data.local.entity.TagEntity
-
-@Database(
-    entities = [
-        ImageEntity::class,
-        TagEntity::class,
-        PersonEntity::class,
-        EventEntity::class,
-        ImageTagEntity::class,
-        ImagePersonEntity::class,
-        ImageEventEntity::class
-    ],
-    version = 1,
-    exportSchema = true
-)
-
-abstract class AppDatabase : RoomDatabase() {
-
-    abstract fun imageDao(): ImageDao
-    abstract fun tagDao(): TagDao
-    abstract fun personDao(): PersonDao
-    abstract fun eventDao(): EventDao
-
-    abstract fun imageTagDao(): ImageTagDao
-    abstract fun imagePersonDao(): ImagePersonDao
-    abstract fun imageEventDao(): ImageEventDao
-
-    abstract fun imageAggregateDao(): ImageAggregateDao
-}

app/src/main/java/com/placeholder/sherpai2/data/local/dao/EventDao.kt

@@ -1,26 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.placeholder.sherpai2.data.local.entity.EventEntity
-
-@Dao
-interface EventDao {
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun insert(event: EventEntity)
-
-    /**
-     * Find events covering a timestamp.
-     *
-     * This is the backbone of auto-tagging by date.
-     */
-    @Query("""
-        SELECT * FROM events
-        WHERE :timestamp BETWEEN startDate AND endDate
-        AND isHidden = 0
-    """)
-    suspend fun findEventsForTimestamp(timestamp: Long): List<EventEntity>
-}

app/src/main/java/com/placeholder/sherpai2/data/local/dao/ImageAggregateDao.kt

@@ -1,48 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Query
-import androidx.room.Transaction
-import com.placeholder.sherpai2.data.local.model.ImageWithEverything
-import kotlinx.coroutines.flow.Flow
-
-@Dao
-interface ImageAggregateDao {
-
-    /**
-     * Observe a fully-hydrated image object.
-     */
-    @Transaction
-    @Query("""
-        SELECT * FROM images
-        WHERE imageId = :imageId
-    """)
-    fun observeImageWithEverything(
-        imageId: String
-    ): Flow<ImageWithEverything>
-
-    /**
-     * Observe all images.
-     */
-    @Transaction
-    @Query("""
-        SELECT * FROM images
-        ORDER BY capturedAt DESC
-    """)
-    fun observeAllImagesWithEverything(): Flow<List<ImageWithEverything>>
-
-    /**
-     * Observe images filtered by tag value.
-     *
-     * Joins images -> image_tags -> tags
-     */
-    @Transaction
-    @Query("""
-        SELECT images.* FROM images
-        INNER JOIN image_tags ON images.imageId = image_tags.imageId
-        INNER JOIN tags ON tags.tagId = image_tags.tagId
-        WHERE tags.value = :tag
-        ORDER BY images.capturedAt DESC
-    """)
-    fun observeImagesWithTag(tag: String): Flow<List<ImageWithEverything>>
-}

app/src/main/java/com/placeholder/sherpai2/data/local/dao/ImageDao.kt

@@ -1,56 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-import kotlinx.coroutines.flow.Flow
-
-@Dao
-interface ImageDao {
-
-    /**
-     * Insert images.
-     *
-     * IGNORE prevents duplicate insertion
-     * when sha256 or imageUri already exists.
-     */
-    @Insert(onConflict = OnConflictStrategy.IGNORE)
-    suspend fun insertImages(images: List<ImageEntity>)
-
-    /**
-     * Get image by ID.
-     */
-    @Query("SELECT * FROM images WHERE imageId = :imageId")
-    suspend fun getImageById(imageId: String): ImageEntity?
-
-    /**
-     * Stream images ordered by capture time (newest first).
-     *
-     * Flow is critical:
-     * - UI auto-updates
-     * - No manual refresh
-     */
-    @Query("""
-        SELECT * FROM images
-        ORDER BY capturedAt DESC
-    """)
-    fun observeAllImages(): Flow<List<ImageEntity>>
-
-    /**
-     * Fetch images in a time range.
-     * Used for:
-     * - event auto-assignment
-     * - timeline views
-     */
-    @Query("""
-        SELECT * FROM images
-        WHERE capturedAt BETWEEN :start AND :end
-        ORDER BY capturedAt ASC
-    """)
-    suspend fun getImagesInRange(
-        start: Long,
-        end: Long
-    ): List<ImageEntity>
-}

app/src/main/java/com/placeholder/sherpai2/data/local/dao/ImageEventDao.kt

@@ -1,23 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.placeholder.sherpai2.data.local.entity.ImageEventEntity
-
-@Dao
-interface ImageEventDao {
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun upsert(entity: ImageEventEntity)
-
-    /**
-     * Images associated with an event.
-     */
-    @Query("""
-        SELECT imageId FROM image_events
-        WHERE eventId = :eventId
-    """)
-    suspend fun findImagesForEvent(eventId: String): List<String>
-}

app/src/main/java/com/placeholder/sherpai2/data/local/dao/ImagePersonDao.kt

@@ -1,25 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.placeholder.sherpai2.data.local.entity.ImagePersonEntity
-
-@Dao
-interface ImagePersonDao {
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun upsert(entity: ImagePersonEntity)
-
-    /**
-     * All images containing a specific person.
-     */
-    @Query("""
-        SELECT imageId FROM image_persons
-        WHERE personId = :personId
-        AND visibility = 'PUBLIC'
-        AND confirmed = 1
-    """)
-    suspend fun findImagesForPerson(personId: String): List<String>
-}

app/src/main/java/com/placeholder/sherpai2/data/local/dao/ImageTagDao.kt

@@ -1,53 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import androidx.room.Transaction
-import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
-import com.placeholder.sherpai2.data.local.entity.TagEntity
-import kotlinx.coroutines.flow.Flow
-
-@Dao
-interface ImageTagDao {
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun upsert(imageTag: ImageTagEntity)
-
-    /**
-     * Observe tags for an image.
-     */
-    @Query("""
-        SELECT * FROM image_tags
-        WHERE imageId = :imageId
-        AND visibility != 'HIDDEN'
-    """)
-    fun observeTagsForImage(imageId: String): Flow<List<ImageTagEntity>>
-
-    /**
-     * Find images by tag.
-     *
-     * This is your primary tag-search query.
-     */
-    @Query("""
-        SELECT imageId FROM image_tags
-        WHERE tagId = :tagId
-        AND visibility = 'PUBLIC'
-        AND confidence >= :minConfidence
-    """)
-    suspend fun findImagesByTag(
-        tagId: String,
-        minConfidence: Float = 0.5f
-    ): List<String>
-
-    @Transaction
-    @Query("""
-        SELECT t.* 
-        FROM tags t
-        INNER JOIN image_tags it ON t.tagId = it.tagId
-        WHERE it.imageId = :imageId AND it.visibility = 'PUBLIC'
-    """)
-    fun getTagsForImage(imageId: String): Flow<List<TagEntity>>
-
-}

app/src/main/java/com/placeholder/sherpai2/data/local/dao/PersonDao.kt

@@ -1,24 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.placeholder.sherpai2.data.local.entity.PersonEntity
-
-@Dao
-interface PersonDao {
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun insert(person: PersonEntity)
-
-    @Query("SELECT * FROM persons WHERE personId = :personId")
-    suspend fun getById(personId: String): PersonEntity?
-
-    @Query("""
-        SELECT * FROM persons
-        WHERE isHidden = 0
-        ORDER BY displayName
-    """)
-    suspend fun getVisiblePeople(): List<PersonEntity>
-}

app/src/main/java/com/placeholder/sherpai2/data/local/dao/TagDao.kt

@@ -1,24 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.placeholder.sherpai2.data.local.entity.TagEntity
-
-@Dao
-interface TagDao {
-
-    @Insert(onConflict = OnConflictStrategy.IGNORE)
-    suspend fun insert(tag: TagEntity)
-
-    /**
-     * Resolve a tag by value.
-     * Example: "park"
-     */
-    @Query("SELECT * FROM tags WHERE value = :value LIMIT 1")
-    suspend fun getByValue(value: String): TagEntity?
-
-    @Query("SELECT * FROM tags")
-    suspend fun getAll(): List<TagEntity>
-}

app/src/main/java/com/placeholder/sherpai2/data/local/entity/EventEntity.kt

@@ -1,44 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.Index
-import androidx.room.PrimaryKey
-
-/**
- * Represents a meaningful event spanning a time range.
- *
- * Events allow auto-association of images by timestamp.
- */
-@Entity(
-    tableName = "events",
-    indices = [
-        Index(value = ["startDate"]),
-        Index(value = ["endDate"])
-    ]
-)
-data class EventEntity(
-
-    @PrimaryKey
-    val eventId: String,
-
-    val name: String,
-
-    /**
-     * Inclusive start date (UTC millis).
-     */
-    val startDate: Long,
-
-    /**
-     * Inclusive end date (UTC millis).
-     */
-    val endDate: Long,
-
-    val location: String?,
-
-    /**
-     * 0.0 – 1.0 importance weight
-     */
-    val importance: Float,
-
-    val isHidden: Boolean
-)

app/src/main/java/com/placeholder/sherpai2/data/local/entity/ImageEntity.kt

@@ -1,55 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.Index
-import androidx.room.PrimaryKey
-
-/**
- * Represents a single image on the device.
- *
- * This entity is intentionally immutable:
- * - imageUri identifies where the image lives
- * - sha256 prevents duplicates
- * - capturedAt is the EXIF timestamp
- *
- * This table should be append-only.
- */
-@Entity(
-    tableName = "images",
-    indices = [
-        Index(value = ["imageUri"], unique = true),
-        Index(value = ["sha256"], unique = true),
-        Index(value = ["capturedAt"])
-    ]
-)
-data class ImageEntity(
-
-    @PrimaryKey
-    val imageId: String,
-
-    val imageUri: String,
-
-    /**
-     * Cryptographic hash of image bytes.
-     * Used for deduplication and re-indexing.
-     */
-    val sha256: String,
-
-    /**
-     * EXIF timestamp (UTC millis).
-     */
-    val capturedAt: Long,
-
-    /**
-     * When this image was indexed into the app.
-     */
-    val ingestedAt: Long,
-
-    val width: Int,
-    val height: Int,
-
-    /**
-     * CAMERA | SCREENSHOT | IMPORTED
-     */
-    val source: String
-)

app/src/main/java/com/placeholder/sherpai2/data/local/entity/ImageEventEntity.kt

@@ -1,42 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.ForeignKey
-import androidx.room.Index
-
-@Entity(
-    tableName = "image_events",
-    primaryKeys = ["imageId", "eventId"],
-    foreignKeys = [
-        ForeignKey(
-            entity = ImageEntity::class,
-            parentColumns = ["imageId"],
-            childColumns = ["imageId"],
-            onDelete = ForeignKey.CASCADE
-        ),
-        ForeignKey(
-            entity = EventEntity::class,
-            parentColumns = ["eventId"],
-            childColumns = ["eventId"],
-            onDelete = ForeignKey.CASCADE
-        )
-    ],
-    indices = [
-        Index("eventId")
-    ]
-)
-data class ImageEventEntity(
-
-    val imageId: String,
-    val eventId: String,
-
-    /**
-     * AUTO | MANUAL
-     */
-    val source: String,
-
-    /**
-     * User override flag.
-     */
-    val override: Boolean
-)

app/src/main/java/com/placeholder/sherpai2/data/local/entity/ImagePersonEntity.kt

@@ -1,40 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.ForeignKey
-import androidx.room.Index
-
-@Entity(
-    tableName = "image_persons",
-    primaryKeys = ["imageId", "personId"],
-    foreignKeys = [
-        ForeignKey(
-            entity = ImageEntity::class,
-            parentColumns = ["imageId"],
-            childColumns = ["imageId"],
-            onDelete = ForeignKey.CASCADE
-        ),
-        ForeignKey(
-            entity = PersonEntity::class,
-            parentColumns = ["personId"],
-            childColumns = ["personId"],
-            onDelete = ForeignKey.CASCADE
-        )
-    ],
-    indices = [
-        Index("personId")
-    ]
-)
-data class ImagePersonEntity(
-
-    val imageId: String,
-    val personId: String,
-
-    val confidence: Float,
-    val confirmed: Boolean,
-
-    /**
-     * PUBLIC | PRIVATE
-     */
-    val visibility: String
-)

app/src/main/java/com/placeholder/sherpai2/data/local/entity/ImageTagEntity.kt

@@ -1,56 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.ForeignKey
-import androidx.room.Index
-
-/**
- * Join table linking images to tags.
- *
- * This is NOT optional.
- * Do not inline tag lists on ImageEntity.
- */
-@Entity(
-    tableName = "image_tags",
-    primaryKeys = ["imageId", "tagId"],
-    foreignKeys = [
-        ForeignKey(
-            entity = ImageEntity::class,
-            parentColumns = ["imageId"],
-            childColumns = ["imageId"],
-            onDelete = ForeignKey.CASCADE
-        ),
-        ForeignKey(
-            entity = TagEntity::class,
-            parentColumns = ["tagId"],
-            childColumns = ["tagId"],
-            onDelete = ForeignKey.CASCADE
-        )
-    ],
-    indices = [
-        Index("tagId"),
-        Index("imageId")
-    ]
-)
-data class ImageTagEntity(
-
-    val imageId: String,
-    val tagId: String,
-
-    /**
-     * AUTO | MANUAL
-     */
-    val source: String,
-
-    /**
-     * ML confidence (0–1).
-     */
-    val confidence: Float,
-
-    /**
-     * PUBLIC | PRIVATE | HIDDEN
-     */
-    val visibility: String,
-
-    val createdAt: Long
-)

app/src/main/java/com/placeholder/sherpai2/data/local/entity/PersonsEntity.kt

@@ -1,30 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-
-/**
- * Represents a known person.
- *
- * People are separate from generic tags because:
- * - face embeddings
- * - privacy rules
- * - identity merging
- */
-@Entity(tableName = "persons")
-data class PersonEntity(
-
-    @PrimaryKey
-    val personId: String,
-
-    val displayName: String,
-
-    /**
-     * Reference to face embedding storage (ML layer).
-     */
-    val faceEmbeddingId: String?,
-
-    val isHidden: Boolean,
-
-    val createdAt: Long
-)

app/src/main/java/com/placeholder/sherpai2/data/local/entity/TagEntity.kt

@@ -1,30 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-
-/**
- * Represents a conceptual tag.
- *
- * Tags are normalized so that:
- * - "park" exists once
- * - many images can reference it
- */
-@Entity(tableName = "tags")
-data class TagEntity(
-
-    @PrimaryKey
-    val tagId: String,
-
-    /**
-     * GENERIC | SYSTEM | HIDDEN
-     */
-    val type: String,
-
-    /**
-     * Human-readable value, e.g. "park", "sunset"
-     */
-    val value: String,
-
-    val createdAt: Long
-)

app/src/main/java/com/placeholder/sherpai2/data/local/model/ImageWithEverything.kt

@@ -1,29 +0,0 @@
-package com.placeholder.sherpai2.data.local.model
-
-import androidx.room.Embedded
-import androidx.room.Relation
-import com.placeholder.sherpai2.data.local.entity.*
-
-data class ImageWithEverything(
-
-    @Embedded
-    val image: ImageEntity,
-
-    @Relation(
-        parentColumn = "imageId",
-        entityColumn = "imageId"
-    )
-    val tags: List<ImageTagEntity>,
-
-    @Relation(
-        parentColumn = "imageId",
-        entityColumn = "imageId"
-    )
-    val persons: List<ImagePersonEntity>,
-
-    @Relation(
-        parentColumn = "imageId",
-        entityColumn = "imageId"
-    )
-    val events: List<ImageEventEntity>
-)

app/src/main/java/com/placeholder/sherpai2/data/local/model/ImageWithTags.kt

@@ -1,18 +0,0 @@
-package com.placeholder.sherpai2.data.local.model
-
-import androidx.room.Embedded
-import androidx.room.Relation
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
-
-data class ImageWithTags(
-
-    @Embedded
-    val image: ImageEntity,
-
-    @Relation(
-        parentColumn = "imageId",
-        entityColumn = "imageId"
-    )
-    val tags: List<ImageTagEntity>
-)

app/src/main/java/com/placeholder/sherpai2/data/photos/Photo.kt

@@ -1,13 +1,10 @@
 package com.placeholder.sherpai2.data.photos
 
-import android.net.Uri
-
 data class Photo(
-    val id: Long,
+    val id: String,
-    val uri: Uri,
+    val uri: String,
     val title: String? = null,
-    val size: Long,
+    val timestamp: Long
-    val dateModified: Int
 )
 
 data class Album(

app/src/main/java/com/placeholder/sherpai2/data/photos/SamplePhoto.kt

@@ -0,0 +1,25 @@
+package com.placeholder.sherpai2.data.photos
+
+import com.placeholder.sherpai2.data.photos.Photo
+
+object SamplePhotoSource {
+
+    fun loadPhotos(): List<Photo> {
+        return listOf(
+            Photo(
+                id = "1",
+                uri = "file:///sdcard/Pictures/20200115_181335.jpg",
+                title = "Sample One",
+                timestamp = System.currentTimeMillis()
+            ),
+            Photo(
+                id = "2",
+                uri = "file:///sdcard/Pictures/20200115_181417.jpg",
+                title = "Sample Two",
+                timestamp = System.currentTimeMillis()
+            )
+        )
+    }
+}
+ // /sdcard/Pictures/20200115_181335.jpg
+// /sdcard/Pictures/20200115_181417.jpg

app/src/main/java/com/placeholder/sherpai2/data/repo/PhotoRepository.kt

@@ -1,50 +1,11 @@
 package com.placeholder.sherpai2.data.repo
 
-import android.content.Context
-import android.provider.MediaStore
-import android.content.ContentUris
-import android.net.Uri
-import android.os.Environment
-import android.util.Log
 import com.placeholder.sherpai2.data.photos.Photo
-import kotlinx.coroutines.Dispatchers
+import com.placeholder.sherpai2.data.photos.SamplePhotoSource
-import kotlinx.coroutines.withContext
-import java.io.File
 
-class PhotoRepository(private val context: Context) {
+class PhotoRepository {
 
-    fun scanExternalStorage(): Result<List<Photo>> {
+    fun getPhotos(): List<Photo> {
-        // Best Practice: Use Environment.getExternalStorageDirectory()
+        return SamplePhotoSource.loadPhotos()
-        // only as a fallback or starting point for legacy support.
-        val rootPath = Environment.getExternalStorageDirectory()
-
-        return runCatching {
-            val photos = mutableListOf<Photo>()
-
-            if (rootPath.exists() && rootPath.isDirectory) {
-                // walkTopDown is efficient but can throw AccessDeniedException
-                rootPath.walkTopDown()
-                    .maxDepth(3) // Performance Best Practice: Don't scan the whole phone
-                    .filter { it.isFile && isImageFile(it.extension) }
-                    .forEach { file ->
-                        photos.add(mapFileToPhoto(file))
     }
-            }
-            photos
-        }.onFailure { e ->
-            Log.e("PhotoRepo", "Failed to scan filesystem", e)
-        }
-    }
-
-    private fun mapFileToPhoto(file: File): Photo {
-        return Photo(
-            id = file.path.hashCode().toLong(),
-            uri = Uri.fromFile(file),
-            title = file.name,
-            size = file.length(),
-            dateModified = (file.lastModified() / 1000).toInt()
-        )
-    }
-
-    private fun isImageFile(ext: String) = listOf("jpg", "jpeg", "png").contains(ext.lowercase())
 }

app/src/main/java/com/placeholder/sherpai2/di/DatabaseModule.kt

@@ -1,61 +0,0 @@
-package com.placeholder.sherpai2.di
-
-import android.content.Context
-import androidx.room.Room
-import com.placeholder.sherpai2.data.local.AppDatabase
-import com.placeholder.sherpai2.data.local.dao.ImageAggregateDao
-import com.placeholder.sherpai2.data.local.dao.ImageEventDao
-import com.placeholder.sherpai2.data.local.dao.ImageTagDao
-import com.placeholder.sherpai2.data.local.dao.TagDao
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.components.SingletonComponent
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-object DatabaseModule {
-
-    @Provides
-    @Singleton
-    fun provideDatabase(
-        @ApplicationContext context: Context
-    ): AppDatabase {
-        return Room.databaseBuilder(
-            context,
-            AppDatabase::class.java,
-            "sherpai.db"
-        ).build()
-    }
-
-    // --- Add these DAO providers ---
-
-    @Provides
-    fun provideTagDao(database: AppDatabase): TagDao {
-        return database.tagDao()
-    }
-
-    @Provides
-    fun provideImageTagDao(database: AppDatabase): ImageTagDao {
-        return database.imageTagDao()
-    }
-
-    // Add providers for your other DAOs now to avoid future errors
-    @Provides
-    fun provideImageDao(database: AppDatabase) = database.imageDao()
-
-    @Provides
-    fun providePersonDao(database: AppDatabase) = database.personDao()
-
-    @Provides
-    fun provideEventDao(database: AppDatabase) = database.eventDao()
-
-    @Provides
-    fun provideImageEventDao(database: AppDatabase): ImageEventDao = database.imageEventDao()
-
-    @Provides
-    fun provideImageAggregateDao(database: AppDatabase): ImageAggregateDao = database.imageAggregateDao()
-}
-

app/src/main/java/com/placeholder/sherpai2/di/RepositoryModule.kt

@@ -1,28 +0,0 @@
-package com.placeholder.sherpai2.di
-
-import com.placeholder.sherpai2.data.repository.ImageRepositoryImpl
-import com.placeholder.sherpai2.data.repository.TaggingRepositoryImpl
-import com.placeholder.sherpai2.domain.repository.ImageRepository
-import com.placeholder.sherpai2.domain.repository.TaggingRepository
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-abstract class RepositoryModule {
-
-    @Binds
-    @Singleton
-    abstract fun bindImageRepository(
-        impl: ImageRepositoryImpl
-    ): ImageRepository
-
-    @Binds
-    @Singleton
-    abstract fun bindTaggingRepository(
-        impl: TaggingRepositoryImpl
-    ): TaggingRepository
-}

app/src/main/java/com/placeholder/sherpai2/domain/PhotoFunctions.kt

@@ -1,3 +0,0 @@
-package com.placeholder.sherpai2.domain
-
-//fun getAllPhotos(context: Context): List<Photo> {

app/src/main/java/com/placeholder/sherpai2/domain/PhotoScanner.kt

@@ -1,7 +0,0 @@
-package com.placeholder.sherpai2.domain
-
-import android.content.Context
-
-class PhotoDuplicateScanner(private val context: Context) {
-
-}

app/src/main/java/com/placeholder/sherpai2/domain/repository/ImageRepository.kt

@@ -1,31 +0,0 @@
-package com.placeholder.sherpai2.domain.repository
-
-import com.placeholder.sherpai2.data.local.model.ImageWithEverything
-import kotlinx.coroutines.flow.Flow
-
-/**
- * Canonical access point for images.
- *
- * ViewModels must NEVER talk directly to DAOs.
- */
-interface ImageRepository {
-
-    /**
-     * Observe a fully-hydrated image graph.
-     *
-     * Used by detail screens.
-     */
-    fun observeImage(imageId: String): Flow<ImageWithEverything>
-
-    /**
-     * Ingest images discovered on device.
-     *
-     * This function:
-     * - deduplicates
-     * - assigns events automatically
-     */
-    suspend fun ingestImages()
-
-    fun getAllImages(): Flow<List<ImageWithEverything>>
-    fun findImagesByTag(tag: String): Flow<List<ImageWithEverything>>
-}

app/src/main/java/com/placeholder/sherpai2/domain/repository/ImageRepositoryImpl.kt

@@ -1,64 +0,0 @@
-package com.placeholder.sherpai2.data.repository
-
-import com.placeholder.sherpai2.data.local.dao.EventDao
-import com.placeholder.sherpai2.data.local.dao.ImageAggregateDao
-import com.placeholder.sherpai2.data.local.dao.ImageDao
-import com.placeholder.sherpai2.data.local.dao.ImageEventDao
-import com.placeholder.sherpai2.data.local.entity.ImageEventEntity
-import com.placeholder.sherpai2.domain.repository.ImageRepository
-import kotlinx.coroutines.flow.Flow
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class ImageRepositoryImpl @Inject constructor(
-    private val imageDao: ImageDao,
-    private val eventDao: EventDao,
-    private val imageEventDao: ImageEventDao,
-    private val aggregateDao: ImageAggregateDao
-) : ImageRepository {
-
-    override fun observeImage(imageId: String): Flow<com.placeholder.sherpai2.data.local.model.ImageWithEverything> {
-        return aggregateDao.observeImageWithEverything(imageId)
-    }
-
-    /**
-     * Ingest images from device.
-     *
-     * NOTE:
-     * Actual MediaStore scanning is deliberately omitted here.
-     * This function assumes images already exist in ImageDao.
-     */
-    override suspend fun ingestImages() {
-        // Step 1: fetch all images
-        val images = imageDao.getImagesInRange(
-            start = 0L,
-            end = Long.MAX_VALUE
-        )
-
-        // Step 2: auto-assign events by timestamp
-        images.forEach { image ->
-            val events = eventDao.findEventsForTimestamp(image.capturedAt)
-
-            events.forEach { event ->
-                imageEventDao.upsert(
-                    ImageEventEntity(
-                        imageId = image.imageId,
-                        eventId = event.eventId,
-                        source = "AUTO",
-                        override = false
-                    )
-                )
-            }
-        }
-    }
-
-    override fun getAllImages(): Flow<List<com.placeholder.sherpai2.data.local.model.ImageWithEverything>> {
-        return aggregateDao.observeAllImagesWithEverything()
-    }
-
-    override fun findImagesByTag(tag: String): Flow<List<com.placeholder.sherpai2.data.local.model.ImageWithEverything>> {
-        // Assuming aggregateDao can filter images by tag
-        return aggregateDao.observeImagesWithTag(tag)
-    }
-}

app/src/main/java/com/placeholder/sherpai2/domain/repository/TaggingRepository.kt

@@ -1,30 +0,0 @@
-package com.placeholder.sherpai2.domain.repository
-
-import com.placeholder.sherpai2.data.local.entity.TagEntity
-import kotlinx.coroutines.flow.Flow
-
-/**
- * Handles all tagging operations.
- *
- * This repository is the ONLY place where:
- * - tags are attached
- * - visibility rules are applied
- */
-interface TaggingRepository {
-
-    suspend fun addTagToImage(
-        imageId: String,
-        tagValue: String,
-        source: String,
-        confidence: Float
-    )
-
-    suspend fun hideTagForImage(
-        imageId: String,
-        tagValue: String
-    )
-
-    fun getTagsForImage(imageId: String): Flow<List<TagEntity>>
-
-    suspend fun removeTagFromImage(imageId: String, tagId: String)
-}

app/src/main/java/com/placeholder/sherpai2/domain/repository/TaggingRepositoryImpl.kt

@@ -1,97 +0,0 @@
-package com.placeholder.sherpai2.data.repository
-
-import com.placeholder.sherpai2.data.local.dao.ImageTagDao
-import com.placeholder.sherpai2.data.local.dao.TagDao
-import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
-import com.placeholder.sherpai2.data.local.entity.TagEntity
-import com.placeholder.sherpai2.domain.repository.TaggingRepository
-import kotlinx.coroutines.flow.Flow
-import javax.inject.Inject
-import javax.inject.Singleton
-
-/**
- *
- *
- * Critical design decisions here
- *
- * Tag normalization happens once
- *
- * Visibility rules live here
- *
- * ML and manual tagging share the same path
- */
-
-@Singleton
-class TaggingRepositoryImpl @Inject constructor(
-    private val tagDao: TagDao,
-    private val imageTagDao: ImageTagDao
-) : TaggingRepository {
-
-    override suspend fun addTagToImage(
-        imageId: String,
-        tagValue: String,
-        source: String,
-        confidence: Float
-    ) {
-        // Step 1: normalize tag
-        val normalized = tagValue.trim().lowercase()
-
-        // Step 2: ensure tag exists
-        val tag = tagDao.getByValue(normalized)
-            ?: TagEntity(
-                tagId = "tag_$normalized",
-                type = "GENERIC",
-                value = normalized,
-                createdAt = System.currentTimeMillis()
-            ).also { tagDao.insert(it) }
-
-        // Step 3: attach tag to image
-        imageTagDao.upsert(
-            ImageTagEntity(
-                imageId = imageId,
-                tagId = tag.tagId,
-                source = source,
-                confidence = confidence,
-                visibility = "PUBLIC",
-                createdAt = System.currentTimeMillis()
-            )
-        )
-    }
-
-    override suspend fun hideTagForImage(
-        imageId: String,
-        tagValue: String
-    ) {
-        val tag = tagDao.getByValue(tagValue) ?: return
-
-        imageTagDao.upsert(
-            ImageTagEntity(
-                imageId = imageId,
-                tagId = tag.tagId,
-                source = "MANUAL",
-                confidence = 1.0f,
-                visibility = "HIDDEN",
-                createdAt = System.currentTimeMillis()
-            )
-        )
-    }
-
-    override fun getTagsForImage(imageId: String): Flow<List<TagEntity>> {
-        // Join imageTagDao -> tagDao to get all PUBLIC tags for this image
-        return imageTagDao.getTagsForImage(imageId)
-    }
-
-    override suspend fun removeTagFromImage(imageId: String, tagId: String) {
-        // Mark the tag as hidden instead of deleting, keeping the visibility logic
-        imageTagDao.upsert(
-            ImageTagEntity(
-                imageId = imageId,
-                tagId = tagId,
-                source = "MANUAL",
-                confidence = 1.0f,
-                visibility = "HIDDEN",
-                createdAt = System.currentTimeMillis()
-            )
-        )
-    }
-}

app/src/main/java/com/placeholder/sherpai2/navigation/AppDestinations.kt

@@ -0,0 +1,42 @@
+// In navigation/AppDestinations.kt
+package com.placeholder.sherpai2.navigation
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.ui.graphics.vector.ImageVector
+
+/**
+ * Defines all navigation destinations (screens) for the application.
+ */
+sealed class AppDestinations(val route: String, val icon: ImageVector, val label: String) {
+    // Core Functional Sections
+    object Tour : AppDestinations(
+        route = "Tour",
+        icon = Icons.Default.PhotoLibrary,
+        label = "Tour"
+    )
+    object Search : AppDestinations("search", Icons.Default.Search, "Search")
+    object Models : AppDestinations("models", Icons.Default.Layers, "Models")
+    object Inventory : AppDestinations("inv", Icons.Default.Inventory2, "Inv")
+    object Train : AppDestinations("train", Icons.Default.TrackChanges, "Train")
+    object Tags : AppDestinations("tags", Icons.Default.LocalOffer, "Tags")
+
+    // Utility/Secondary Sections
+    object Upload : AppDestinations("upload", Icons.Default.CloudUpload, "Upload")
+    object Settings : AppDestinations("settings", Icons.Default.Settings, "Settings")
+}
+
+// Lists used by the AppDrawerContent to render the menu sections easily
+val mainDrawerItems = listOf(
+    AppDestinations.Tour,
+    AppDestinations.Search,
+    AppDestinations.Models,
+    AppDestinations.Inventory,
+    AppDestinations.Train,
+    AppDestinations.Tags
+)
+
+val utilityDrawerItems = listOf(
+    AppDestinations.Upload,
+    AppDestinations.Settings
+)

app/src/main/java/com/placeholder/sherpai2/navigation/MainScreen.kt

@@ -0,0 +1,57 @@
+// In presentation/MainScreen.kt
+package com.placeholder.sherpai2.presentation
+
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Menu
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import com.placeholder.sherpai2.navigation.AppDestinations
+import kotlinx.coroutines.launch
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun MainScreen() {
+    val drawerState = rememberDrawerState(initialValue = DrawerValue.Closed)
+    val scope = rememberCoroutineScope()
+    // State to track which screen is currently visible
+    // var currentScreen by remember { mutableStateOf(AppDestinations.Search) }
+    var currentScreen: AppDestinations by remember { mutableStateOf(AppDestinations.Search) }
+
+    // ModalNavigationDrawer provides the left sidebar UI/UX
+    ModalNavigationDrawer(
+        drawerState = drawerState,
+        drawerContent = {
+            // The content of the drawer (AppDrawerContent)
+            AppDrawerContent(
+                currentScreen = currentScreen,
+                onDestinationClicked = { destination ->
+                    currentScreen = destination
+                    scope.launch { drawerState.close() } // Close drawer after selection
+                }
+            )
+        },
+    ) {
+        // The main content area
+        Scaffold(
+            topBar = {
+                TopAppBar(
+                    title = { Text(currentScreen.label) },
+                    // Button to open the drawer
+                    navigationIcon = {
+                        IconButton(onClick = { scope.launch { drawerState.open() } }) {
+                            Icon(Icons.Filled.Menu, contentDescription = "Open Drawer")
+                        }
+                    }
+                )
+            }
+        ) { paddingValues ->
+            // Displays the content for the currently selected screen
+            MainContentArea(
+                currentScreen = currentScreen,
+                modifier = Modifier.padding(paddingValues)
+            )
+        }
+    }
+}

app/src/main/java/com/placeholder/sherpai2/presentation/AppDrawerContent.kt

@@ -0,0 +1,59 @@
+// In presentation/AppDrawerContent.kt
+package com.placeholder.sherpai2.presentation
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import com.placeholder.sherpai2.navigation.AppDestinations
+import com.placeholder.sherpai2.navigation.mainDrawerItems
+import com.placeholder.sherpai2.navigation.utilityDrawerItems
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun AppDrawerContent(
+    currentScreen: AppDestinations,
+    onDestinationClicked: (AppDestinations) -> Unit
+) {
+    // Defines the width and content of the sliding drawer panel
+    ModalDrawerSheet(modifier = Modifier.width(280.dp)) {
+
+        // Header/Logo Area
+        Text(
+            "SherpAI Control Panel",
+            style = MaterialTheme.typography.headlineSmall,
+            modifier = Modifier.padding(16.dp)
+        )
+        Divider(Modifier.fillMaxWidth())
+
+        // 1. Main Navigation Items
+        Column(modifier = Modifier.padding(vertical = 8.dp)) {
+            mainDrawerItems.forEach { destination ->
+                NavigationDrawerItem(
+                    label = { Text(destination.label) },
+                    icon = { Icon(destination.icon, contentDescription = destination.label) },
+                    selected = destination == currentScreen,
+                    onClick = { onDestinationClicked(destination) },
+                    modifier = Modifier.padding(NavigationDrawerItemDefaults.ItemPadding)
+                )
+            }
+        }
+
+        // Separator
+        Divider(Modifier.fillMaxWidth().padding(vertical = 8.dp))
+
+        // 2. Utility Items
+        Column(modifier = Modifier.padding(vertical = 8.dp)) {
+            utilityDrawerItems.forEach { destination ->
+                NavigationDrawerItem(
+                    label = { Text(destination.label) },
+                    icon = { Icon(destination.icon, contentDescription = destination.label) },
+                    selected = destination == currentScreen,
+                    onClick = { onDestinationClicked(destination) },
+                    modifier = Modifier.padding(NavigationDrawerItemDefaults.ItemPadding)
+                )
+            }
+        }
+    }
+}

app/src/main/java/com/placeholder/sherpai2/presentation/MainContentArea.kt

@@ -0,0 +1,104 @@
+// In presentation/MainContentArea.kt
+package com.placeholder.sherpai2.presentation
+
+import androidx.compose.ui.graphics.Color
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import com.placeholder.sherpai2.navigation.AppDestinations
+import com.placeholder.sherpai2.ui.theme.SherpAI2Theme
+
+@Composable
+fun MainContentArea(currentScreen: AppDestinations, modifier: Modifier = Modifier) {
+    Box(
+        modifier = modifier
+            .fillMaxSize()
+            .background(MaterialTheme.colorScheme.surfaceVariant),
+        contentAlignment = Alignment.Center
+    ) {
+        // Swaps the UI content based on the selected screen from the drawer
+        when (currentScreen) {
+            AppDestinations.Tour -> TwinAlbumScreen("New Collections." , "Classics")
+            AppDestinations.Search -> SimplePlaceholder("Search for your photo.")
+            AppDestinations.Models -> SimplePlaceholder("Models Screen: Manage your LoRA/embeddings.")
+            AppDestinations.Inventory -> SimplePlaceholder("Inventory Screen: View all collected data.")
+            AppDestinations.Train -> SimplePlaceholder("Train Screen: Start the LoRA adaptation process.")
+            AppDestinations.Tags -> SimplePlaceholder("Tags Screen: Create and edit custom tags.")
+            AppDestinations.Upload -> SimplePlaceholder("Upload Screen: Import new photos/data.")
+            AppDestinations.Settings -> SimplePlaceholder("Settings Screen: Configure app behavior.")
+        }
+    }
+}
+
+@Composable
+private fun SimplePlaceholder(text: String) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.titleLarge,
+        modifier = Modifier.padding(16.dp)
+    )
+}
+
+
+@Composable
+fun AlbumPreview(title: String, color: Color) {
+    Box(
+        modifier = Modifier
+            .padding(8.dp)
+            .aspectRatio(1f) // Makes it a square
+            .background(color, shape = RoundedCornerShape(12.dp)),
+        contentAlignment = Alignment.Center
+    ) {
+        Text(text = title, color = Color.White, fontWeight = FontWeight.Bold)
+    }
+}
+
+@Composable
+fun TwinAlbumScreen(albumNameA: String, albumNameB: String) {
+    Column(modifier = Modifier.fillMaxSize()) {
+        // --- Top 40% Section ---
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .weight(0.30f) // This takes exactly 40% of vertical space
+                .padding(16.dp),
+            horizontalArrangement = Arrangement.spacedBy(2.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            // These two occupy the 40% area
+            Box(modifier = Modifier.weight(1f)) {
+                AlbumPreview("Mackenzie Hazer", Color.Blue)
+            }
+            Box(modifier = Modifier.weight(1f)) {
+                AlbumPreview("Winifred", Color.Magenta)
+            }
+        }
+
+        // --- Bottom 60% Section ---
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .weight(0.6f) // This takes the remaining 60%
+                .background(Color.LightGray.copy(alpha = 0.2f))
+        ) {
+            Text("Other content goes here", modifier = Modifier.align(Alignment.Center))
+        }
+    }
+}
+@Preview
+@Composable
+fun PreviewTwinTopRow() {
+    SherpAI2Theme {
+        TwinAlbumScreen("Album A", "Album B")
+    }
+}
+
+

app/src/main/java/com/placeholder/sherpai2/presentation/PhotoListScreen.kt

@@ -0,0 +1,35 @@
+package com.placeholder.sherpai2.presentation
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+
+import coil.compose.rememberAsyncImagePainter
+
+import com.placeholder.sherpai2.data.photos.Photo
+import com.placeholder.sherpai2.data.photos.SamplePhotoSource
+
+@Composable
+fun PhotoListScreen(
+    photos: List<Photo>
+) {
+    LazyColumn(
+        modifier = Modifier.fillMaxSize(),
+        contentPadding = PaddingValues(8.dp)
+    ) {
+        items(photos, key = { it.id }) { photo ->
+            Image(
+                painter = rememberAsyncImagePainter(photo.uri),
+                contentDescription = photo.title,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(200.dp)
+                    .padding(bottom = 8.dp)
+            )
+        }
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/imagedetail/ImageDetailScreen.kt

@@ -1,86 +0,0 @@
-package com.placeholder.sherpai2.ui.imagedetail
-
-import androidx.compose.foundation.layout.*
-import androidx.compose.material3.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.dp
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import coil.compose.AsyncImage
-import com.placeholder.sherpai2.ui.imagedetail.viewmodel.ImageDetailViewModel
-
-
-
-
-/**
- * ImageDetailScreen
- *
- * Purpose:
- *  - Add tags
- *  - Remove tags
- *  - Validate write propagation
- */
-@Composable
-fun ImageDetailScreen(
-    modifier: Modifier = Modifier,
-    imageUri: String,
-    onBack: () -> Unit
-) {
-    val viewModel: ImageDetailViewModel = androidx.lifecycle.viewmodel.compose.viewModel()
-
-    LaunchedEffect(imageUri) {
-        viewModel.loadImage(imageUri)
-    }
-
-    val tags by viewModel.tags.collectAsStateWithLifecycle()
-
-    var newTag by remember { mutableStateOf("") }
-
-    Column(
-        modifier = modifier
-            .fillMaxSize()
-            .padding(12.dp)
-    ) {
-
-        AsyncImage(
-            model = imageUri,
-            contentDescription = null,
-            modifier = Modifier
-                .fillMaxWidth()
-                .aspectRatio(1f)
-        )
-
-        Spacer(modifier = Modifier.height(12.dp))
-
-        OutlinedTextField(
-            value = newTag,
-            onValueChange = { newTag = it },
-            label = { Text("Add tag") },
-            modifier = Modifier.fillMaxWidth()
-        )
-
-        Button(
-            onClick = {
-                viewModel.addTag(newTag)
-                newTag = ""
-            },
-            modifier = Modifier.padding(top = 8.dp)
-        ) {
-            Text("Add Tag")
-        }
-
-        Spacer(modifier = Modifier.height(16.dp))
-
-        tags.forEach { tag ->
-            Row(
-                horizontalArrangement = Arrangement.SpaceBetween,
-                modifier = Modifier.fillMaxWidth()
-            ) {
-                Text(tag.value)
-                TextButton(onClick = { viewModel.removeTag(tag) }) {
-                    Text("Remove")
-                }
-            }
-        }
-    }
-}

app/src/main/java/com/placeholder/sherpai2/ui/imagedetail/viewmodel/ImageDetailViewModel.kt

@@ -1,57 +0,0 @@
-package com.placeholder.sherpai2.ui.imagedetail.viewmodel
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.placeholder.sherpai2.data.local.entity.TagEntity
-import com.placeholder.sherpai2.domain.repository.TaggingRepository
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-/**
- * ImageDetailViewModel
- *
- * Owns:
- *  - Image context
- *  - Tag write operations
- */
-@HiltViewModel
-@OptIn(ExperimentalCoroutinesApi::class)
-class ImageDetailViewModel @Inject constructor(
-    private val tagRepository: TaggingRepository
-) : ViewModel() {
-
-    private val imageUri = MutableStateFlow<String?>(null)
-
-    val tags: StateFlow<List<TagEntity>> =
-        imageUri
-            .filterNotNull()
-            .flatMapLatest { uri ->
-                tagRepository.getTagsForImage(uri)
-            }
-            .stateIn(
-                scope = viewModelScope,
-                started = SharingStarted.WhileSubscribed(5_000),
-                initialValue = emptyList()
-            )
-
-    fun loadImage(uri: String) {
-        imageUri.value = uri
-    }
-
-    fun addTag(value: String) {
-        val uri = imageUri.value ?: return
-        viewModelScope.launch {
-            tagRepository.addTagToImage(uri, value, source = "MANUAL", confidence = 1.0f)
-        }
-    }
-
-    fun removeTag(tag: TagEntity) {
-        val uri = imageUri.value ?: return
-        viewModelScope.launch {
-            tagRepository.removeTagFromImage(uri, tag.value)
-        }
-    }
-}

app/src/main/java/com/placeholder/sherpai2/ui/navigation/AppDestinations.kt

@@ -1,83 +0,0 @@
-package com.placeholder.sherpai2.ui.navigation
-
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.*
-import androidx.compose.ui.graphics.vector.ImageVector
-
-/**
- * AppDestinations
- *
- * Centralized definition of all top-level screens.
- * This avoids stringly-typed navigation.
- */
-sealed class AppDestinations(
-    val route: String,
-    val icon: ImageVector,
-    val label: String
-) {
-
-    object Tour : AppDestinations(
-        route = "tour",
-        icon = Icons.Default.PhotoLibrary,
-        label = "Tour"
-    )
-
-    object Search : AppDestinations(
-        route = "search",
-        icon = Icons.Default.Search,
-        label = "Search"
-    )
-
-    object Models : AppDestinations(
-        route = "models",
-        icon = Icons.Default.Layers,
-        label = "Models"
-    )
-
-    object Inventory : AppDestinations(
-        route = "inventory",
-        icon = Icons.Default.Inventory2,
-        label = "Inventory"
-    )
-
-    object Train : AppDestinations(
-        route = "train",
-        icon = Icons.Default.TrackChanges,
-        label = "Train"
-    )
-
-    object Tags : AppDestinations(
-        route = "tags",
-        icon = Icons.Default.LocalOffer,
-        label = "Tags"
-    )
-
-    object Upload : AppDestinations(
-        route = "upload",
-        icon = Icons.Default.CloudUpload,
-        label = "Upload"
-    )
-
-    object Settings : AppDestinations(
-        route = "settings",
-        icon = Icons.Default.Settings,
-        label = "Settings"
-    )
-}
-
-/**
- * Drawer grouping
- */
-val mainDrawerItems = listOf(
-    AppDestinations.Tour,
-    AppDestinations.Search,
-    AppDestinations.Models,
-    AppDestinations.Inventory,
-    AppDestinations.Train,
-    AppDestinations.Tags
-)
-
-val utilityDrawerItems = listOf(
-    AppDestinations.Upload,
-    AppDestinations.Settings
-)

app/src/main/java/com/placeholder/sherpai2/ui/search/SearchScreen.kt

@@ -1,70 +0,0 @@
-package com.placeholder.sherpai2.ui.search
-
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.lazy.grid.*
-import androidx.compose.material3.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.dp
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.placeholder.sherpai2.ui.search.components.ImageGridItem
-import com.placeholder.sherpai2.ui.search.SearchViewModel
-
-/**
- * SearchScreen
- *
- * Purpose:
- *  - Validate tag-based queries
- *  - Preview matching images
- *
- * This is NOT final UX.
- * It is a diagnostic surface.
- */
-@Composable
-fun SearchScreen(
-    modifier: Modifier = Modifier,
-    searchViewModel: SearchViewModel,
-    onImageClick: (String) -> Unit
-) {
-
-    var query by remember { mutableStateOf("") }
-
-    /**
-     * Reactive result set.
-     * Updates whenever:
-     *  - query changes
-     *  - database changes
-     */
-    val images by searchViewModel
-        .searchImagesByTag(query)
-        .collectAsStateWithLifecycle(initialValue = emptyList())
-
-    Column(
-        modifier = modifier
-            .fillMaxSize()
-            .padding(12.dp)
-    ) {
-
-        OutlinedTextField(
-            value = query,
-            onValueChange = { query = it },
-            label = { Text("Search by tag") },
-            modifier = Modifier.fillMaxWidth(),
-            singleLine = true
-        )
-
-        Spacer(modifier = Modifier.height(12.dp))
-
-        LazyVerticalGrid(
-            columns = GridCells.Adaptive(120.dp),
-            contentPadding = PaddingValues(4.dp),
-            verticalArrangement = Arrangement.spacedBy(4.dp),
-            horizontalArrangement = Arrangement.spacedBy(4.dp),
-            modifier = Modifier.fillMaxSize()
-        ) {
-            items(images) { imageWithEverything ->
-                ImageGridItem(image = imageWithEverything.image)
-            }
-        }
-    }
-}

app/src/main/java/com/placeholder/sherpai2/ui/search/SearchViewModel.kt

@@ -1,24 +0,0 @@
-package com.placeholder.sherpai2.ui.search
-
-import androidx.lifecycle.ViewModel
-import com.placeholder.sherpai2.domain.repository.ImageRepository
-import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
-
-/**
- * SearchViewModel
- *
- * Stateless except for query-driven flows.
- */
-@HiltViewModel
-class SearchViewModel @Inject constructor(
-    private val imageRepository: ImageRepository
-) : ViewModel() {
-
-    fun searchImagesByTag(tag: String) =
-        if (tag.isBlank()) {
-            imageRepository.getAllImages()
-        } else {
-            imageRepository.findImagesByTag(tag)
-        }
-}

app/src/main/java/com/placeholder/sherpai2/ui/search/components/ImageGridItem.kt

@@ -1,28 +0,0 @@
-package com.placeholder.sherpai2.ui.search.components
-
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.layout.aspectRatio
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import coil.compose.rememberAsyncImagePainter
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-
-/**
- * ImageGridItem
- *
- * Minimal thumbnail preview.
- * No click handling yet.
- */
-@Composable
-fun ImageGridItem(
-    image: ImageEntity
-) {
-    Image(
-        painter = rememberAsyncImagePainter(image.imageUri),
-        contentDescription = null,
-        modifier = Modifier
-            .fillMaxWidth()
-            .aspectRatio(1f)
-    )
-}

app/src/main/java/com/placeholder/sherpai2/ui/tourscreen/GalleryScreen.kt

@@ -0,0 +1,141 @@
+package com.placeholder.sherpai2.ui.tourscreen
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.placeholder.sherpai2.data.photos.Album
+import com.placeholder.sherpai2.ui.theme.SherpAI2Theme
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.unit.dp
+import coil.compose.AsyncImage
+import com.placeholder.sherpai2.presentation.AlbumPreview
+
+class GalleryScreen {
+}
+
+@Composable
+fun GalleryContent(topAlbums: List<Album>) {
+    Column(modifier = Modifier.fillMaxSize()) {
+        // --- Top 40% Section ---
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .weight(0.4f)
+                .padding(8.dp)
+        ) {
+            // We use .getOrNull to safely check if the albums exist in the list
+            val firstAlbum = topAlbums.getOrNull(0)
+            val secondAlbum = topAlbums.getOrNull(1)
+
+            if (firstAlbum != null) {
+                AlbumPreviewBoxRandom(album = firstAlbum, modifier = Modifier.weight(1f))
+            } else {
+                Box(modifier = Modifier.weight(1f)) // Empty placeholder
+            }
+
+            if (secondAlbum != null) {
+                AlbumPreviewBoxRandom(album = secondAlbum, modifier = Modifier.weight(1f))
+            } else {
+                Box(modifier = Modifier.weight(1f)) // Empty placeholder
+            }
+        }
+
+        // --- Bottom 60% Section ---
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .weight(0.6f)
+        ) {
+            Text("Lower Content Area", modifier = Modifier.align(Alignment.Center))
+        }
+    }
+}
+// --- STATEFUL (Use this for Production) ---
+@Composable
+fun GalleryScreen(viewModel: GalleryViewModel = viewModel()) {
+    val albumList by viewModel.albums
+    GalleryContent(topAlbums = albumList)
+}
+
+// --- PREVIEW ---
+@Preview(showBackground = true)
+@Composable
+fun GalleryPreview() {
+    SherpAI2Theme {
+        // Feed mock data into the Stateless version
+        GalleryContent(topAlbums = listOf(/* Fake Album Objects */))
+    }
+}
+
+
+@Composable
+fun AlbumPreviewBox(
+    album: Album,
+    modifier: Modifier = Modifier
+) {
+    Card(
+        modifier = modifier
+            .padding(8.dp)
+            .aspectRatio(1f), // Keeps it square
+        shape = RoundedCornerShape(12.dp),
+        elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
+    ) {
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .background(Color.DarkGray), // Background until image is loaded
+            contentAlignment = Alignment.BottomStart
+        ) {
+            // Title Overlay
+            Text(
+                text = album.title,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .background(Color.Black.copy(alpha = 0.5f))
+                    .padding(8.dp),
+                color = Color.White,
+                style = MaterialTheme.typography.labelLarge
+            )
+        }
+    }
+}
+
+@Composable
+fun AlbumPreviewBoxRandom(album: Album, modifier: Modifier = Modifier) {
+    Card(
+        modifier = modifier.padding(8.dp).aspectRatio(1f),
+        shape = RoundedCornerShape(12.dp)
+    ) {
+        Row(modifier = Modifier.fillMaxSize()) {
+            // Loop through the 3 random photos in the album
+            album.photos.forEach { photo ->
+                AsyncImage(
+                    model = photo.uri,
+                    contentDescription = null,
+                    modifier = Modifier
+                        .weight(1f)
+                        .fillMaxHeight(),
+                    contentScale = ContentScale.Crop // Fills the space nicely
+                )
+            }
+        }
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/tourscreen/GalleryViewModel.kt

@@ -0,0 +1,97 @@
+package com.placeholder.sherpai2.ui.tourscreen
+
+import android.os.Environment
+import androidx.compose.runtime.mutableStateOf
+import androidx.lifecycle.ViewModel
+import com.placeholder.sherpai2.data.photos.AlbumPhoto
+import androidx.compose.runtime.State
+import androidx.compose.runtime.mutableStateOf
+import androidx.lifecycle.viewModelScope
+import com.placeholder.sherpai2.data.photos.Album // Import your data model
+import com.placeholder.sherpai2.data.photos.Photo
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.File
+
+class GalleryViewModel : ViewModel() {
+    // This is the 'albums' reference your UI is looking for
+    private val _albums = mutableStateOf<List<Album>>(emptyList())
+    val albums: State<List<Album>> = _albums
+
+    init {
+        fetchInitialData()
+    }
+
+    private fun fetchInitialData() {
+        viewModelScope.launch(Dispatchers.IO) {
+            val directory = File("/sdcard/photos") // Or: Environment.getExternalStorageDirectory()
+
+            if (directory.exists() && directory.isDirectory) {
+                val photoFiles = directory.listFiles { file ->
+                    file.extension.lowercase() in listOf("jpg", "jpeg", "png")
+                } ?: emptyArray()
+
+                // Map files to your Photo data class
+                val loadedPhotos = photoFiles.map { file ->
+                    Photo(
+                        id = file.absolutePath,
+                        uri = file.toURI().toString(),
+                        title = file.nameWithoutExtension,
+                        timestamp = file.lastModified()
+                    )
+                }
+
+                // Create an Album object with these photos
+                val mainAlbum = Album(
+                    id = "local_photos",
+                    title = "Phone Gallery",
+                    photos = loadedPhotos
+                )
+
+                // Update the UI State on the Main Thread
+                withContext(Dispatchers.Main) {
+                    _albums.value = listOf(mainAlbum)
+                }
+            }
+        }
+    }
+
+    private fun fetchInitialDataRandom() {
+        viewModelScope.launch(Dispatchers.IO) {
+            val root = Environment.getExternalStorageDirectory()
+            val directory = File(root, "photos")
+
+            if (directory.exists() && directory.isDirectory) {
+                // 1. Filter specifically for .jpg files
+                val photoFiles = directory.listFiles { file ->
+                    file.extension.lowercase() == "jpg"
+                } ?: emptyArray()
+
+                // 2. Shuffle the list and take only the first 3
+                val randomPhotos = photoFiles.asSequence()
+                    .shuffled()
+                    .take(3)
+                    .map { file ->
+                        Photo(
+                            id = file.absolutePath,
+                            uri = file.toURI().toString(),
+                            title = file.nameWithoutExtension,
+                            timestamp = file.lastModified()
+                        )
+                    }.toList()
+
+                // 3. Update the state with these 3 random photos
+                val mainAlbum = Album(
+                    id = "random_selection",
+                    title = "Random Picks",
+                    photos = randomPhotos
+                )
+
+                withContext(Dispatchers.Main) {
+                    _albums.value = listOf(mainAlbum)
+                }
+            }
+        }
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/tourscreen/components/AlbumBox.kt

@@ -0,0 +1,4 @@
+package com.placeholder.sherpai2.ui.tourscreen.components
+
+class AlbumBox {
+}

build.gradle.kts

@@ -3,9 +3,4 @@ plugins {
     alias(libs.plugins.android.application) apply false
     alias(libs.plugins.kotlin.android) apply false
     alias(libs.plugins.kotlin.compose) apply false
-
-    //Adding these two fixes the conflicts between hilt / room / ksp and javbapoet (cannonicalName())
-    //https://github.com/google/dagger/issues/4048#issuecomment-1864237679
-    alias(libs.plugins.ksp) apply false
-    alias(libs.plugins.hilt.android) apply false
 }

gradle/libs.versions.toml

@@ -1,56 +1,32 @@
 [versions]
-# Tooling
+agp = "8.13.1"
-agp = "8.13.2"
 kotlin = "2.0.21"
-ksp = "2.0.21-1.0.28"
+coreKtx = "1.17.0"
-
+junit = "4.13.2"
-# AndroidX / Lifecycle
+junitVersion = "1.3.0"
-coreKtx = "1.15.0"
+espressoCore = "3.7.0"
-lifecycle = "2.8.7"
+lifecycleRuntimeKtx = "2.10.0"
-activityCompose = "1.9.3"
+activityCompose = "1.12.1"
-composeBom = "2025.12.01"
+composeBom = "2024.09.00"
-navigationCompose = "2.8.5"
-hiltNavigationCompose = "1.3.0"
-
-# DI & Database
-hilt = "2.57.2"
-room = "2.8.4"
-
-# Images
-coil = "2.7.0"
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
-androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle" }
+junit = { group = "junit", name = "junit", version.ref = "junit" }
-androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
+androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
+androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
+androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtx" }
 androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
-
-# Compose
 androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
 androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }
 androidx-compose-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
 androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
 androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+androidx-compose-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
+androidx-compose-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
 androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
-androidx-compose-material-icons = { group = "androidx.compose.material", name = "material-icons-extended" }
-
-# Navigation & Hilt
-androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigationCompose" }
-androidx-hilt-navigation-compose = { group = "androidx.hilt", name = "hilt-navigation-compose", version.ref = "hiltNavigationCompose" }
-hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" }
-hilt-compiler = { group = "com.google.dagger", name = "hilt-compiler", version.ref = "hilt" }
-
-# Room
-room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
-room-ktx = { group = "androidx.room", name = "room-ktx", version.ref = "room" }
-room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }
-
-# Misc
-coil-compose = { group = "io.coil-kt", name = "coil-compose", version.ref = "coil" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
-ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
+
-hilt-android = { id = "com.google.dagger.hilt.android", version.ref = "hilt" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 #Tue Dec 09 23:28:28 EST 2025
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists