@shaykec/app-agent 1.0.0

package/templates/android/MapTemplate/app/src/main/kotlin/com/appship/map/AppConfig.kt

@@ -0,0 +1,78 @@
+package com.appship.map
+
+import androidx.compose.ui.graphics.Color
+import com.appship.map.core.theme.Primary
+import com.appship.map.core.theme.Secondary
+import com.appship.map.core.theme.AccentColor as ThemeAccent
+import com.appship.map.data.Category
+import com.appship.map.data.CategoryColor
+
+// CUSTOMIZE:BRANDING - App identity and configuration
+object AppConfig {
+    const val APP_NAME = "MapTemplate"
+    const val PACKAGE_NAME = "com.appship.map"
+    const val VERSION = "1.0.0"
+    
+    // CUSTOMIZE:FEATURES
+    object Features {
+        const val ENABLE_DIRECTIONS = true
+        const val ENABLE_REVIEWS = true
+        const val ENABLE_FILTERS = true
+        const val ENABLE_GEOFENCE = false
+        const val ENABLE_OFFLINE_MAPS = false
+        const val ENABLE_CHECKIN = false
+        const val ENABLE_ROUTE_TRACKING = false
+        const val ENABLE_AR_VIEW = false
+        const val ENABLE_FAVORITES = true
+    }
+    
+    // CUSTOMIZE:API
+    object Api {
+        const val BASE_URL = "https://api.example.com"
+        const val API_VERSION = "v1"
+        const val TIMEOUT_SECONDS = 30L
+        const val PLACES_ENDPOINT = "/places"
+        const val SEARCH_ENDPOINT = "/search"
+        const val DIRECTIONS_ENDPOINT = "/directions"
+    }
+    
+    // CUSTOMIZE:CONTENT
+    object Content {
+        const val SUPPORT_EMAIL = "support@example.com"
+        const val PRIVACY_POLICY_URL = "https://example.com/privacy"
+        const val TERMS_URL = "https://example.com/terms"
+        const val MAP_ATTRIBUTION = "© OpenStreetMap contributors"
+    }
+    
+    // CUSTOMIZE:THEME — colors are defined in core/theme/Theme.kt
+    object Theme {
+        val primaryColor get() = Primary
+        val secondaryColor get() = Secondary
+        val accentColor get() = ThemeAccent
+    }
+    
+    // CUSTOMIZE:CATEGORIES
+    val CATEGORIES = listOf(
+        Category(id = "restaurants", name = "Restaurants", icon = "restaurant", color = CategoryColor.RED),
+        Category(id = "cafes", name = "Cafes", icon = "local_cafe", color = CategoryColor.BROWN),
+        Category(id = "shopping", name = "Shopping", icon = "shopping_bag", color = CategoryColor.BLUE),
+        Category(id = "entertainment", name = "Entertainment", icon = "movie", color = CategoryColor.PURPLE),
+        Category(id = "parks", name = "Parks", icon = "park", color = CategoryColor.GREEN),
+        Category(id = "museums", name = "Museums", icon = "museum", color = CategoryColor.ORANGE),
+        Category(id = "hotels", name = "Hotels", icon = "hotel", color = CategoryColor.CYAN),
+        Category(id = "services", name = "Services", icon = "build", color = CategoryColor.GRAY)
+    )
+    
+    // CUSTOMIZE:ONBOARDING
+    data class OnboardingSlide(
+        val title: String,
+        val subtitle: String,
+        val icon: String
+    )
+    
+    val ONBOARDING_SLIDES = listOf(
+        OnboardingSlide("Discover Places", "Find amazing restaurants, cafes, and attractions near you", "map"),
+        OnboardingSlide("Get Directions", "Navigate easily with turn-by-turn directions", "directions"),
+        OnboardingSlide("Save Favorites", "Keep track of your favorite places", "favorite")
+    )
+}

package/templates/android/MapTemplate/app/src/main/kotlin/com/appship/map/MainActivity.kt

@@ -0,0 +1,29 @@
+package com.appship.map
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.ui.Modifier
+import com.appship.map.core.theme.MapTemplateTheme
+import com.appship.map.features.navigation.MainScreen
+import dagger.hilt.android.AndroidEntryPoint
+
+@AndroidEntryPoint
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            MapTemplateTheme {
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.background
+                ) {
+                    MainScreen()
+                }
+            }
+        }
+    }
+}

package/templates/android/MapTemplate/app/src/main/kotlin/com/appship/map/MapApplication.kt

@@ -0,0 +1,7 @@
+package com.appship.map
+
+import android.app.Application
+import dagger.hilt.android.HiltAndroidApp
+
+@HiltAndroidApp
+class MapApplication : Application()

package/templates/android/MapTemplate/app/src/main/kotlin/com/appship/map/core/theme/Theme.kt

@@ -0,0 +1,125 @@
+package com.appship.map.core.theme
+
+import android.app.Activity
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Typography
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.SideEffect
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.platform.LocalView
+import androidx.core.view.WindowCompat
+
+// CUSTOMIZE:THEME - Define your brand colors
+val Primary = Color(0xFF0077FF)
+val OnPrimary = Color.White
+val PrimaryContainer = Color(0xFFD6E3FF)
+val OnPrimaryContainer = Color(0xFF001B3D)
+
+val Secondary = Color(0xFFF2F2F7)
+val OnSecondary = Color.Black
+val SecondaryContainer = Color(0xFFE0E0E5)
+val OnSecondaryContainer = Color(0xFF1C1C1E)
+
+val AccentColor = Color(0xFFFF9500)
+val OnAccent = Color.White
+
+val Error = Color(0xFFBA1A1A)
+val OnError = Color.White
+val ErrorContainer = Color(0xFFFFDAD6)
+val OnErrorContainer = Color(0xFF410002)
+
+val Background = Color(0xFFFAFAFA)
+val OnBackground = Color.Black
+val Surface = Color.White
+val OnSurface = Color.Black
+val SurfaceVariant = Color(0xFFE3E1EC)
+val OnSurfaceVariant = Color(0xFF46464F)
+
+val Outline = Color(0xFF77767F)
+val OutlineVariant = Color(0xFFC7C5D0)
+
+// Map-specific colors
+val MapPinColor = Color(0xFFFF3B30)
+val MapRouteColor = Color(0xFF0077FF)
+val FavoriteColor = Color(0xFFFF3B30)
+val RatingColor = Color(0xFFFF9500)
+
+val Success = Color(0xFF4CAF50)
+val Warning = Color(0xFFFF9800)
+
+private val DarkColorScheme = darkColorScheme(
+    primary = Primary,
+    onPrimary = OnPrimary,
+    primaryContainer = Primary,
+    onPrimaryContainer = OnPrimaryContainer,
+    secondary = Secondary,
+    onSecondary = OnSecondary,
+    secondaryContainer = SecondaryContainer,
+    onSecondaryContainer = OnSecondaryContainer,
+    tertiary = AccentColor,
+    onTertiary = OnAccent,
+    error = Error,
+    onError = OnError,
+    errorContainer = ErrorContainer,
+    onErrorContainer = OnErrorContainer,
+    background = Color(0xFF121212),
+    onBackground = Color.White,
+    surface = Color(0xFF1E1E1E),
+    onSurface = Color.White,
+    surfaceVariant = Color(0xFF46464F),
+    onSurfaceVariant = Color(0xFFC7C5D0),
+    outline = Outline,
+    outlineVariant = OutlineVariant
+)
+
+private val LightColorScheme = lightColorScheme(
+    primary = Primary,
+    onPrimary = OnPrimary,
+    primaryContainer = Primary.copy(alpha = 0.1f),
+    onPrimaryContainer = OnPrimaryContainer,
+    secondary = Secondary,
+    onSecondary = OnSecondary,
+    secondaryContainer = SecondaryContainer,
+    onSecondaryContainer = OnSecondaryContainer,
+    tertiary = AccentColor,
+    onTertiary = OnAccent,
+    error = Error,
+    onError = OnError,
+    errorContainer = ErrorContainer,
+    onErrorContainer = OnErrorContainer,
+    background = Background,
+    onBackground = OnBackground,
+    surface = Surface,
+    onSurface = OnSurface,
+    surfaceVariant = SurfaceVariant,
+    onSurfaceVariant = OnSurfaceVariant,
+    outline = Outline,
+    outlineVariant = OutlineVariant
+)
+
+@Composable
+fun MapTemplateTheme(
+    darkTheme: Boolean = isSystemInDarkTheme(),
+    content: @Composable () -> Unit
+) {
+    val colorScheme = if (darkTheme) DarkColorScheme else LightColorScheme
+    
+    val view = LocalView.current
+    if (!view.isInEditMode) {
+        SideEffect {
+            val window = (view.context as Activity).window
+            window.statusBarColor = colorScheme.background.toArgb()
+            WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = !darkTheme
+        }
+    }
+
+    MaterialTheme(
+        colorScheme = colorScheme,
+        typography = Typography(),
+        content = content
+    )
+}

package/templates/android/MapTemplate/app/src/main/kotlin/com/appship/map/data/LocalPersistence.kt

@@ -0,0 +1,68 @@
+package com.appship.map.data
+
+import android.content.Context
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import dagger.hilt.android.qualifiers.ApplicationContext
+import java.io.File
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class LocalPersistence @Inject constructor(
+    @ApplicationContext private val context: Context
+) {
+    val gson = Gson()
+    
+    fun getFile(filename: String): File {
+        return File(context.filesDir, "$filename.json")
+    }
+    
+    fun <T> save(value: T, filename: String) {
+        val file = getFile(filename)
+        try {
+            val json = gson.toJson(value)
+            file.writeText(json)
+        } catch (e: Exception) {
+            android.util.Log.e("LocalPersistence", "Failed to save $filename: ${e.message}")
+        }
+    }
+    
+    fun <T> load(filename: String, type: Class<T>): T? {
+        val file = getFile(filename)
+        if (!file.exists()) return null
+        
+        return try {
+            val json = file.readText()
+            gson.fromJson(json, type)
+        } catch (e: Exception) {
+            android.util.Log.e("LocalPersistence", "Failed to load $filename: ${e.message}")
+            null
+        }
+    }
+    
+    internal inline fun <reified T> load(filename: String): T? {
+        val file = getFile(filename)
+        if (!file.exists()) return null
+        
+        return try {
+            val json = file.readText()
+            val type = object : TypeToken<T>() {}.type
+            gson.fromJson(json, type)
+        } catch (e: Exception) {
+            android.util.Log.e("LocalPersistence", "Failed to load $filename: ${e.message}")
+            null
+        }
+    }
+    
+    fun delete(filename: String) {
+        val file = getFile(filename)
+        if (file.exists()) {
+            file.delete()
+        }
+    }
+    
+    fun exists(filename: String): Boolean {
+        return getFile(filename).exists()
+    }
+}

package/templates/android/MapTemplate/app/src/main/kotlin/com/appship/map/data/Models.kt

@@ -0,0 +1,298 @@
+package com.appship.map.data
+
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+import java.util.Date
+
+// MARK: - Place
+@Parcelize
+data class Place(
+    val id: String,
+    var name: String,
+    var description: String,
+    var category: Category,
+    var address: String,
+    var coordinate: Coordinate,
+    var rating: Double,
+    var reviewCount: Int,
+    var priceLevel: PriceLevel,
+    var hours: OpenHours? = null,
+    var phone: String? = null,
+    var website: String? = null,
+    var photos: List<String> = emptyList(),
+    var isFavorite: Boolean = false
+) : Parcelable
+
+// MARK: - Category
+@Parcelize
+data class Category(
+    val id: String,
+    var name: String,
+    var icon: String,
+    var color: CategoryColor
+) : Parcelable
+
+enum class CategoryColor {
+    RED, BLUE, GREEN, ORANGE, PURPLE, BROWN, CYAN, GRAY, PINK, YELLOW
+}
+
+// MARK: - Review
+@Parcelize
+data class Review(
+    val id: String,
+    var author: String,
+    var authorAvatar: String? = null,
+    var rating: Double,
+    var content: String,
+    var createdAt: Date,
+    var helpfulCount: Int = 0,
+    var isHelpful: Boolean = false
+) : Parcelable {
+    fun formattedDate(): String {
+        val now = System.currentTimeMillis()
+        val diff = now - createdAt.time
+        val days = diff / (1000 * 60 * 60 * 24)
+        return when {
+            days < 1 -> "Today"
+            days < 7 -> "${days}d ago"
+            days < 30 -> "${days / 7}w ago"
+            days < 365 -> "${days / 30}mo ago"
+            else -> "${days / 365}y ago"
+        }
+    }
+}
+
+// MARK: - Route
+@Parcelize
+data class Route(
+    val id: String,
+    var origin: Coordinate,
+    var destination: Coordinate,
+    var waypoints: List<Coordinate> = emptyList(),
+    var distance: Double, // in meters
+    var duration: Long, // in seconds
+    var polyline: String = "", // encoded polyline
+    var steps: List<RouteStep> = emptyList()
+) : Parcelable {
+    fun formattedDistance(): String {
+        return if (distance < 1000) {
+            "${distance.toInt()} m"
+        } else {
+            String.format("%.1f km", distance / 1000)
+        }
+    }
+    
+    fun formattedDuration(): String {
+        val minutes = (duration / 60).toInt()
+        val hours = minutes / 60
+        val remainingMinutes = minutes % 60
+        
+        return if (hours > 0) {
+            "${hours}h ${remainingMinutes}m"
+        } else {
+            "${minutes}m"
+        }
+    }
+}
+
+@Parcelize
+data class RouteStep(
+    val id: String,
+    var instruction: String,
+    var distance: Double,
+    var duration: Long,
+    var coordinate: Coordinate,
+    var maneuver: ManeuverType
+) : Parcelable {
+    fun formattedDistance(): String {
+        return if (distance < 1000) {
+            "${distance.toInt()} m"
+        } else {
+            String.format("%.1f km", distance / 1000)
+        }
+    }
+}
+
+enum class ManeuverType {
+    TURN_LEFT,
+    TURN_RIGHT,
+    TURN_SHARP_LEFT,
+    TURN_SHARP_RIGHT,
+    TURN_SLIGHT_LEFT,
+    TURN_SLIGHT_RIGHT,
+    STRAIGHT,
+    U_TURN,
+    ARRIVE,
+    DEPART,
+    MERGE,
+    ROUNDABOUT
+}
+
+// MARK: - Coordinate
+@Parcelize
+data class Coordinate(
+    var latitude: Double,
+    var longitude: Double
+) : Parcelable {
+    fun distanceTo(other: Coordinate): Double {
+        val earthRadius = 6371000.0 // meters
+        val dLat = Math.toRadians(other.latitude - latitude)
+        val dLon = Math.toRadians(other.longitude - longitude)
+        val a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+                Math.cos(Math.toRadians(latitude)) * Math.cos(Math.toRadians(other.latitude)) *
+                Math.sin(dLon / 2) * Math.sin(dLon / 2)
+        val c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+        return earthRadius * c
+    }
+}
+
+// MARK: - Filter Criteria
+@Parcelize
+data class FilterCriteria(
+    var categories: List<String> = emptyList(),
+    var minRating: Double = 0.0,
+    var maxDistance: Double? = null, // in meters, null = no limit
+    var priceLevels: List<PriceLevel> = emptyList(),
+    var openNow: Boolean = false
+) : Parcelable {
+    fun isActive(): Boolean {
+        return categories.isNotEmpty() ||
+                minRating > 0.0 ||
+                maxDistance != null ||
+                priceLevels.isNotEmpty() ||
+                openNow
+    }
+    
+    fun reset() {
+        categories = emptyList()
+        minRating = 0.0
+        maxDistance = null
+        priceLevels = emptyList()
+        openNow = false
+    }
+}
+
+// MARK: - Open Hours
+@Parcelize
+data class OpenHours(
+    var monday: DayHours? = null,
+    var tuesday: DayHours? = null,
+    var wednesday: DayHours? = null,
+    var thursday: DayHours? = null,
+    var friday: DayHours? = null,
+    var saturday: DayHours? = null,
+    var sunday: DayHours? = null
+) : Parcelable {
+    fun hoursForDay(day: Weekday): DayHours? {
+        return when (day) {
+            Weekday.MONDAY -> monday
+            Weekday.TUESDAY -> tuesday
+            Weekday.WEDNESDAY -> wednesday
+            Weekday.THURSDAY -> thursday
+            Weekday.FRIDAY -> friday
+            Weekday.SATURDAY -> saturday
+            Weekday.SUNDAY -> sunday
+        }
+    }
+    
+    fun isOpenNow(): Boolean {
+        val calendar = java.util.Calendar.getInstance()
+        val dayOfWeek = calendar.get(java.util.Calendar.DAY_OF_WEEK)
+        val hour = calendar.get(java.util.Calendar.HOUR_OF_DAY)
+        val minute = calendar.get(java.util.Calendar.MINUTE)
+        val currentTime = hour * 60 + minute
+        
+        val day = when (dayOfWeek) {
+            java.util.Calendar.SUNDAY -> Weekday.SUNDAY
+            java.util.Calendar.MONDAY -> Weekday.MONDAY
+            java.util.Calendar.TUESDAY -> Weekday.TUESDAY
+            java.util.Calendar.WEDNESDAY -> Weekday.WEDNESDAY
+            java.util.Calendar.THURSDAY -> Weekday.THURSDAY
+            java.util.Calendar.FRIDAY -> Weekday.FRIDAY
+            java.util.Calendar.SATURDAY -> Weekday.SATURDAY
+            else -> return false
+        }
+        
+        val dayHours = hoursForDay(day) ?: return false
+        
+        return dayHours.periods.any { period ->
+            val openTime = period.open.hour * 60 + period.open.minute
+            val closeTime = period.close.hour * 60 + period.close.minute
+            
+            if (closeTime > openTime) {
+                currentTime >= openTime && currentTime < closeTime
+            } else {
+                currentTime >= openTime || currentTime < closeTime
+            }
+        }
+    }
+}
+
+@Parcelize
+data class DayHours(
+    var periods: List<TimePeriod> = emptyList(),
+    var isClosed: Boolean = false
+) : Parcelable
+
+@Parcelize
+data class TimePeriod(
+    var open: Time,
+    var close: Time
+) : Parcelable
+
+@Parcelize
+data class Time(
+    var hour: Int,
+    var minute: Int
+) : Parcelable {
+    fun formatted(): String {
+        return String.format("%02d:%02d", hour, minute)
+    }
+}
+
+enum class Weekday {
+    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
+}
+
+// MARK: - Price Level
+enum class PriceLevel(val value: Int) {
+    FREE(0),
+    INEXPENSIVE(1),
+    MODERATE(2),
+    EXPENSIVE(3),
+    VERY_EXPENSIVE(4);
+    
+    fun symbol(): String {
+        return when (this) {
+            FREE -> "Free"
+            INEXPENSIVE -> "$"
+            MODERATE -> "$$"
+            EXPENSIVE -> "$$$"
+            VERY_EXPENSIVE -> "$$$$"
+        }
+    }
+    
+    fun description(): String {
+        return when (this) {
+            FREE -> "Free"
+            INEXPENSIVE -> "Inexpensive"
+            MODERATE -> "Moderate"
+            EXPENSIVE -> "Expensive"
+            VERY_EXPENSIVE -> "Very Expensive"
+        }
+    }
+    
+    companion object {
+        val ALL = values().toList()
+    }
+}
+
+// MARK: - User
+@Parcelize
+data class User(
+    val id: String,
+    var name: String,
+    var email: String,
+    var avatarURL: String? = null,
+    var favoritePlaces: List<String> = emptyList()
+) : Parcelable

package/templates/android/MapTemplate/app/src/main/kotlin/com/appship/map/data/NetworkMonitor.kt

@@ -0,0 +1,65 @@
+package com.appship.map.data
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class NetworkMonitor @Inject constructor(
+    @ApplicationContext private val context: Context
+) {
+    private val connectivityManager =
+        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+    
+    val isOnline: Flow<Boolean> = callbackFlow {
+        val callback = object : ConnectivityManager.NetworkCallback() {
+            override fun onAvailable(network: Network) {
+                trySend(true)
+            }
+            
+            override fun onLost(network: Network) {
+                trySend(false)
+            }
+            
+            override fun onCapabilitiesChanged(
+                network: Network,
+                networkCapabilities: NetworkCapabilities
+            ) {
+                val hasInternet = networkCapabilities.hasCapability(
+                    NetworkCapabilities.NET_CAPABILITY_INTERNET
+                ) && networkCapabilities.hasCapability(
+                    NetworkCapabilities.NET_CAPABILITY_VALIDATED
+                )
+                trySend(hasInternet)
+            }
+        }
+        
+        val request = NetworkRequest.Builder()
+            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+            .build()
+        
+        connectivityManager.registerNetworkCallback(request, callback)
+        
+        // Emit initial state
+        trySend(isCurrentlyOnline())
+        
+        awaitClose {
+            connectivityManager.unregisterNetworkCallback(callback)
+        }
+    }
+    
+    private fun isCurrentlyOnline(): Boolean {
+        val network = connectivityManager.activeNetwork ?: return false
+        val capabilities = connectivityManager.getNetworkCapabilities(network) ?: return false
+        return capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
+                capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+    }
+}