Technical Design: Smart Automation Engine

Smart Automation Engine (Core)
├── Input Sources
│   ├── Camera (OCR, Object Detection)
│   ├── PDF/Document Parser
│   └── Manual Entry
├── Domain Recognizers (Pluggable)
│   ├── GroceryRecognizer (MVP 1.0)
│   │   ├── Receipt parsing (Vijetha, BigBasket)
│   │   └── Expiry date extraction
│   ├── ClothingRecognizer (Future)
│   │   ├── Wardrobe photo analysis
│   │   └── Garment type detection
│   └── ToolRecognizer (Future)
│       └── Toolbox photo analysis
└── Output → Domain-specific Items
    ├── GroceryItem (extends Item)
    ├── ClothingItem (extends Item)
    └── ToolItem (extends Item)

// Migration v2 -> v3
val MIGRATION_2_3 = object : Migration(2, 3) {
    override fun migrate(database: SupportSQLiteDatabase) {
        // Item templates table
        database.execSQL("""
            CREATE TABLE IF NOT EXISTS item_templates (
                id TEXT PRIMARY KEY NOT NULL,
                canonicalName TEXT NOT NULL,
                brand TEXT,
                variant TEXT,
                defaultCategory TEXT NOT NULL,
                defaultLocationId TEXT,
                defaultExpiryDays INTEGER,
                defaultUnit TEXT NOT NULL,
                defaultQuantity REAL NOT NULL,
                isCanonical INTEGER NOT NULL DEFAULT 0,
                useCount INTEGER NOT NULL DEFAULT 0,
                createdAt INTEGER NOT NULL,
                lastUsedAt INTEGER
            )
        """)

        // Create index for fast template matching
        database.execSQL("""
            CREATE INDEX idx_template_match
            ON item_templates(canonicalName, brand, variant)
        """)

        // Scan sessions table
        database.execSQL("""
            CREATE TABLE IF NOT EXISTS scan_sessions (
                id TEXT PRIMARY KEY NOT NULL,
                sourceType TEXT NOT NULL,
                sourceName TEXT,
                status TEXT NOT NULL,
                createdAt INTEGER NOT NULL,
                committedAt INTEGER
            )
        """)

        // Staged items table
        database.execSQL("""
            CREATE TABLE IF NOT EXISTS staged_items (
                id TEXT PRIMARY KEY NOT NULL,
                sessionId TEXT NOT NULL,
                rawText TEXT,
                parsedName TEXT NOT NULL,
                parsedBrand TEXT,
                parsedQuantity REAL NOT NULL,
                parsedUnit TEXT NOT NULL,
                confirmedName TEXT,
                confirmedCategory TEXT,
                confirmedLocationId TEXT,
                confirmedExpiryDate INTEGER,
                confirmedQuantity REAL,
                confirmedUnit TEXT,
                status TEXT NOT NULL,
                matchedTemplateId TEXT,
                needsReview INTEGER NOT NULL DEFAULT 0,
                errorMessage TEXT,
                FOREIGN KEY(sessionId) REFERENCES scan_sessions(id) ON DELETE CASCADE
            )
        """)
    }
}

object GroceryTaxonomy {
    val STARTER_TEMPLATES = listOf(
        // Dairy
        Template("Milk", "DAIRY", expiryDays = 7, unit = "L"),
        Template("Curd/Yogurt", "DAIRY", expiryDays = 14, unit = "kg"),
        Template("Paneer", "DAIRY", expiryDays = 7, unit = "g"),
        Template("Butter", "DAIRY", expiryDays = 30, unit = "g"),
        Template("Cheese", "DAIRY", expiryDays = 30, unit = "g"),

        // Produce
        Template("Tomatoes", "PRODUCE", expiryDays = 7, unit = "kg"),
        Template("Onions", "PRODUCE", expiryDays = 30, unit = "kg"),
        Template("Potatoes", "PRODUCE", expiryDays = 21, unit = "kg"),
        Template("Leafy Greens", "PRODUCE", expiryDays = 5, unit = "bunch"),

        // Pantry
        Template("Rice", "PANTRY", expiryDays = 365, unit = "kg"),
        Template("Flour/Atta", "PANTRY", expiryDays = 180, unit = "kg"),
        Template("Oil", "PANTRY", expiryDays = 365, unit = "L"),
        Template("Sugar", "PANTRY", expiryDays = 730, unit = "kg"),
        Template("Salt", "PANTRY", expiryDays = null, unit = "kg"), // No expiry
        Template("Pasta", "PANTRY", expiryDays = 365, unit = "g"),
        Template("Pulses/Dal", "PANTRY", expiryDays = 365, unit = "kg"),

        // Beverages
        Template("Tea", "BEVERAGES", expiryDays = 365, unit = "g"),
        Template("Coffee", "BEVERAGES", expiryDays = 180, unit = "g"),
        Template("Juice", "BEVERAGES", expiryDays = 7, unit = "L"),

        // Meat
        Template("Chicken", "MEAT", expiryDays = 3, unit = "kg"),
        Template("Fish", "MEAT", expiryDays = 2, unit = "kg"),
        Template("Eggs", "MEAT", expiryDays = 21, unit = "unit"),

        // Frozen
        Template("Frozen Vegetables", "FROZEN", expiryDays = 180, unit = "g"),
        Template("Ice Cream", "FROZEN", expiryDays = 90, unit = "L"),

        // Snacks
        Template("Biscuits", "SNACKS", expiryDays = 90, unit = "g"),
        Template("Chips", "SNACKS", expiryDays = 60, unit = "g"),
        Template("Namkeen", "SNACKS", expiryDays = 60, unit = "g")
    )
}

+------------------------------------------+
|           Quick Add Item             [X] |
+------------------------------------------+
|                                          |
|  What are you adding?                    |
|  [Search or type item name______]        |
|                                          |
|  --- Suggestions (from templates) ---    |
|  [Milk] [Bread] [Eggs] [Tomatoes]        |
|  [Onions] [Rice] [+ More...]             |
|                                          |
|  --- Or select category ---              |
|  [Dairy] [Produce] [Meat] [Pantry]       |
|  [Beverages] [Snacks] [Frozen]           |
|                                          |
+------------------------------------------+
|  (After selection, show quick form)      |
|                                          |
|  Milk                                    |
|  Brand:    [Nandini_______________]      |
|  Quantity: [1____] [L     v]             |
|  Expiry:   [7 days from today    v]      |
|            [Custom date...]              |
|  Location: [Fridge > Top Shelf   v]      |
|                                          |
|  [ ] Remember these defaults             |
|                                          |
|  [Cancel]              [Add Item]        |
+------------------------------------------+

@Composable
fun QuickAddScreen(
    onItemAdded: (Item) -> Unit,
    onDismiss: () -> Unit,
    viewModel: QuickAddViewModel = hiltViewModel()
)

@HiltViewModel
class QuickAddViewModel @Inject constructor(
    private val itemRepository: ItemRepository,
    private val templateRepository: ItemTemplateRepository,
    private val locationRepository: LocationRepository
) : ViewModel() {

    val templates: StateFlow<List<ItemTemplate>>
    val recentTemplates: StateFlow<List<ItemTemplate>>
    val locations: StateFlow<List<Location>>

    fun searchTemplates(query: String)
    fun selectTemplate(template: ItemTemplate)
    fun addItem(
        name: String,
        brand: String?,
        category: ItemCategory,
        quantity: Double,
        unit: String,
        expiryDate: Date?,
        locationId: String,
        rememberDefaults: Boolean
    )
}

object TemplateMatching {
    /**
     * Finds a matching template for the given item details.
     * Uses exact match on normalized name + brand + variant.
     */
    fun findMatch(
        name: String,
        brand: String?,
        variant: String?,
        templates: List<ItemTemplate>
    ): ItemTemplate? {
        val normalizedName = normalize(name)
        val normalizedBrand = brand?.let { normalize(it) }
        val normalizedVariant = variant?.let { normalize(it) }

        return templates.find { template ->
            normalize(template.canonicalName) == normalizedName &&
            (normalizedBrand == null || normalize(template.brand) == normalizedBrand) &&
            (normalizedVariant == null || normalize(template.variant) == normalizedVariant)
        }
    }

    /**
     * Normalizes text for matching:
     * - Lowercase
     * - Remove extra whitespace
     * - Remove common suffixes (1L, 500g, etc.)
     */
    private fun normalize(text: String?): String? {
        if (text == null) return null
        return text
            .lowercase()
            .trim()
            .replace(Regex("\\s+"), " ")
            .replace(Regex("\\d+\\s*(kg|g|l|ml|pack|pcs|unit)s?$", RegexOption.IGNORE_CASE), "")
            .trim()
    }
}

First scan of "Nandini Toned Milk 1L"
           │
           ▼
    Template found? ──No──> Show "New Item" dialog
           │                      │
          Yes                     │
           │                      ▼
           ▼              User confirms:
    Apply defaults        - Category: Dairy
    to staged item        - Expiry: 7 days
                          - Location: Fridge
                                │
                                ▼
                         Create template
                         for future scans

+------------------------------------------+
|      New Item Detected               [X] |
+------------------------------------------+
|                                          |
|  "Nandini Toned Milk 1L"                 |
|                                          |
|  We haven't seen this item before.       |
|  Set up defaults for future scans:       |
|                                          |
|  Category:   [ Dairy              v ]    |
|                                          |
|  Expiry:     [ 7 days from scan   v ]    |
|              ( ) Fixed date              |
|              ( ) No expiry               |
|                                          |
|  Default Storage:                        |
|              [ Fridge > Top Shelf v ]    |
|                                          |
|  [Skip (manual each time)]  [Save]       |
+------------------------------------------+

interface ItemTemplateRepository {
    fun getAllTemplates(): Flow<List<ItemTemplate>>
    fun getRecentTemplates(limit: Int = 10): Flow<List<ItemTemplate>>
    fun searchTemplates(query: String): Flow<List<ItemTemplate>>
    fun getTemplatesByCategory(category: ItemCategory): Flow<List<ItemTemplate>>

    suspend fun findMatchingTemplate(
        name: String,
        brand: String?,
        variant: String?
    ): ItemTemplate?

    suspend fun createTemplate(template: ItemTemplate)
    suspend fun updateTemplate(template: ItemTemplate)
    suspend fun incrementUseCount(templateId: String)
    suspend fun deleteTemplate(templateId: String)

    suspend fun seedStarterTemplates()
}

<!-- AndroidManifest.xml -->
<uses-permission android:name="android.permission.CAMERA" />
<uses-feature android:name="android.hardware.camera" android:required="false" />

<!-- ML Kit Text Recognition -->
<meta-data
    android:name="com.google.mlkit.vision.DEPENDENCIES"
    android:value="ocr" />

# gradle/libs.versions.toml
[versions]
mlkit-text = "16.0.0"
camerax = "1.3.1"

[libraries]
mlkit-text-recognition = { module = "com.google.mlkit:text-recognition", version.ref = "mlkit-text" }
camerax-core = { module = "androidx.camera:camera-core", version.ref = "camerax" }
camerax-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "camerax" }
camerax-lifecycle = { module = "androidx.camera:camera-lifecycle", version.ref = "camerax" }
camerax-view = { module = "androidx.camera:camera-view", version.ref = "camerax" }

Camera Capture
      │
      ▼
  InputImage
      │
      ▼
  ML Kit TextRecognizer
      │
      ▼
  Raw Text Blocks
      │
      ▼
  Receipt Parser (store-specific)
      │
      ▼
  List<ParsedLineItem>
      │
      ▼
  Template Matching
      │
      ▼
  Staged Items (for review)

interface ReceiptParser {
    val supportedStores: List<String>

    /**
     * Attempts to parse receipt text into line items.
     * Returns null if the receipt format is not recognized.
     */
    fun parse(rawText: String): ParseResult?
}

data class ParseResult(
    val storeName: String?,
    val date: Date?,
    val items: List<ParsedLineItem>,
    val total: Double?,
    val confidence: Float  // 0.0 to 1.0
)

data class ParsedLineItem(
    val rawText: String,
    val name: String,
    val brand: String?,
    val quantity: Double,
    val unit: String,
    val price: Double?,
    val confidence: Float
)

// Implementations
class VijethaReceiptParser : ReceiptParser { ... }
class OrganicWorldReceiptParser : ReceiptParser { ... }
class GenericReceiptParser : ReceiptParser { ... }  // Fallback

+------------------------------------------+
|  ← Scan Receipt                          |
+------------------------------------------+
|                                          |
|  +------------------------------------+  |
|  |                                    |  |
|  |                                    |  |
|  |         [Camera Preview]           |  |
|  |                                    |  |
|  |    +------------------------+      |  |
|  |    |    Receipt Guide      |      |  |
|  |    |    Align receipt      |      |  |
|  |    |    within frame       |      |  |
|  |    +------------------------+      |  |
|  |                                    |  |
|  |                                    |  |
|  +------------------------------------+  |
|                                          |
|  Tip: Hold steady for best results       |
|                                          |
|  [Gallery]    [  Capture  ]    [Flash]   |
+------------------------------------------+

@HiltViewModel
class ScannerViewModel @Inject constructor(
    private val textRecognizer: TextRecognizer,
    private val receiptParsers: List<ReceiptParser>,
    private val stagingRepository: StagingRepository,
    private val templateRepository: ItemTemplateRepository
) : ViewModel() {

    sealed class ScanState {
        object Idle : ScanState()
        object Scanning : ScanState()
        data class Processing(val progress: Float) : ScanState()
        data class Success(val sessionId: String, val itemCount: Int) : ScanState()
        data class Error(val message: String) : ScanState()
    }

    val scanState: StateFlow<ScanState>

    fun processImage(imageProxy: ImageProxy) {
        viewModelScope.launch {
            _scanState.value = ScanState.Scanning

            try {
                // 1. Run ML Kit OCR
                val inputImage = InputImage.fromMediaImage(
                    imageProxy.image!!,
                    imageProxy.imageInfo.rotationDegrees
                )
                val result = textRecognizer.process(inputImage).await()

                // 2. Parse receipt
                val rawText = result.text
                val parseResult = receiptParsers
                    .firstNotNullOfOrNull { it.parse(rawText) }
                    ?: ParseResult(/* generic fallback */)

                // 3. Match templates and create staging session
                val session = stagingRepository.createSession(
                    sourceType = "OCR",
                    sourceName = parseResult.storeName
                )

                parseResult.items.forEachIndexed { index, item ->
                    _scanState.value = ScanState.Processing(
                        progress = index.toFloat() / parseResult.items.size
                    )

                    val template = templateRepository.findMatchingTemplate(
                        item.name, item.brand, null
                    )

                    stagingRepository.addStagedItem(
                        sessionId = session.id,
                        rawText = item.rawText,
                        parsedName = item.name,
                        parsedBrand = item.brand,
                        parsedQuantity = item.quantity,
                        parsedUnit = item.unit,
                        matchedTemplateId = template?.id,
                        needsReview = template == null
                    )
                }

                _scanState.value = ScanState.Success(session.id, parseResult.items.size)

            } catch (e: Exception) {
                _scanState.value = ScanState.Error(e.message ?: "Scan failed")
            } finally {
                imageProxy.close()
            }
        }
    }
}

[libraries]
# Option 1: PDFBox (simpler, lighter)
pdfbox-android = { module = "com.tom-roush:pdfbox-android", version = "2.0.27.0" }

# Option 2: iText (more powerful, larger)
itext-core = { module = "com.itextpdf:itext7-core", version = "7.2.5" }

class BigBasketPdfParser : InvoiceParser {

    override fun parse(pdfBytes: ByteArray): ParseResult? {
        val document = PDDocument.load(pdfBytes)
        val stripper = PDFTextStripper()
        val text = stripper.getText(document)
        document.close()

        // BigBasket invoice format:
        // - Header with order details
        // - Table with: Item Name | Qty | Price
        // - Footer with totals

        val items = mutableListOf<ParsedLineItem>()

        // Parse line items using regex patterns
        val itemPattern = Regex(
            """(\d+)\.\s+(.+?)\s+(\d+(?:\.\d+)?)\s*(kg|g|L|ml|pcs|pack)?\s+₹?(\d+(?:\.\d+)?)"""
        )

        itemPattern.findAll(text).forEach { match ->
            val (_, name, qty, unit, price) = match.destructured
            items.add(ParsedLineItem(
                rawText = match.value,
                name = name.trim(),
                brand = extractBrand(name),
                quantity = qty.toDoubleOrNull() ?: 1.0,
                unit = unit.ifEmpty { "unit" },
                price = price.toDoubleOrNull(),
                confidence = 0.9f
            ))
        }

        return if (items.isNotEmpty()) {
            ParseResult(
                storeName = "BigBasket",
                date = extractDate(text),
                items = items,
                total = extractTotal(text),
                confidence = 0.85f
            )
        } else null
    }
}

User taps "Import PDF"
        │
        ▼
  Android File Picker
  (ACTION_OPEN_DOCUMENT)
        │
        ▼
  Read PDF content
        │
        ▼
  Parse with BigBasketParser
        │
        ▼
  Create staging session
        │
        ▼
  Navigate to Staging Area

// Add to ItemEntity or GroceryItemEntity
val expiryPhotoUri: String?  // URI to captured photo

// Add to StagedItemEntity
val expiryPhotoUri: String?

+------------------------------------------+
|  Expiry Date                             |
+------------------------------------------+
|                                          |
|  [📅 Pick Date]  [📷 Capture Photo]      |
|                                          |
|  (If photo captured, show thumbnail)     |
|  +------------------+                    |
|  |   [Photo of     |  [X] Remove        |
|  |   expiry date]  |                    |
|  +------------------+                    |
|                                          |
+------------------------------------------+

+------------------------------------------+
|  ← Review Items              [Commit All]|
+------------------------------------------+
|  BigBasket • 12 items • Jan 23, 2026     |
+------------------------------------------+
|                                          |
|  ⚠️ 3 items need attention               |
|                                          |
|  --- Needs Review (3) ---                |
|                                          |
|  +------------------------------------+  |
|  | [!] Nandini Milk 1L                |  |
|  |     Brand: Nandini                 |  |
|  |     → New item - set defaults      |  |
|  |     [Configure]           [Skip]   |  |
|  +------------------------------------+  |
|                                          |
|  +------------------------------------+  |
|  | [!] Unknown Item                   |  |
|  |     Raw: "ORGN WLD HNYLMN 250G"    |  |
|  |     → Couldn't parse              |  |
|  |     [Edit Manually]       [Skip]   |  |
|  +------------------------------------+  |
|                                          |
|  --- Ready to Add (9) ---                |
|                                          |
|  +------------------------------------+  |
|  | ✓ Amul Butter 500g                 |  |
|  |   Qty: 1 • Dairy • Fridge          |  |
|  |   Expires: Feb 23, 2026            |  |
|  |   [Edit]                  [Remove] |  |
|  +------------------------------------+  |
|                                          |
|  ... (more items)                        |
|                                          |
+------------------------------------------+
|  [Discard All]              [Commit All] |
+------------------------------------------+

@HiltViewModel
class StagingViewModel @Inject constructor(
    private val stagingRepository: StagingRepository,
    private val itemRepository: ItemRepository,
    private val templateRepository: ItemTemplateRepository
) : ViewModel() {

    val session: StateFlow<ScanSession?>
    val stagedItems: StateFlow<List<StagedItem>>
    val itemsNeedingReview: StateFlow<List<StagedItem>>
    val readyItems: StateFlow<List<StagedItem>>

    fun loadSession(sessionId: String)

    fun updateStagedItem(
        itemId: String,
        name: String,
        category: ItemCategory,
        quantity: Double,
        unit: String,
        expiryDate: Date?,
        locationId: String
    )

    fun skipItem(itemId: String)
    fun removeItem(itemId: String)

    fun configureNewItem(
        itemId: String,
        category: ItemCategory,
        expiryDays: Int?,
        defaultLocationId: String,
        createTemplate: Boolean
    )

    fun commitAll() {
        viewModelScope.launch {
            val items = readyItems.value
            items.forEach { staged ->
                // Create actual item
                itemRepository.insertGroceryItem(...)

                // Update template use count if matched
                staged.matchedTemplateId?.let {
                    templateRepository.incrementUseCount(it)
                }
            }

            stagingRepository.commitSession(session.value!!.id)
        }
    }

    fun discardAll() {
        viewModelScope.launch {
            stagingRepository.discardSession(session.value!!.id)
        }
    }
}

+------------------------------------------+
|           Add Items                      |
+------------------------------------------+
|                                          |
|  +----------------+  +----------------+  |
|  |                |  |                |  |
|  |   [Camera]     |  |    [PDF]       |  |
|  |   Scan Receipt |  |  Import Invoice|  |
|  |                |  |                |  |
|  +----------------+  +----------------+  |
|                                          |
|  +------------------------------------+  |
|  |                                    |  |
|  |        [Quick Add]                 |  |
|  |        Add items manually          |  |
|  |                                    |  |
|  +------------------------------------+  |
|                                          |
|  --- Recent Scans ---                    |
|  [BigBasket • 12 items • Today]          |
|  [Vijetha • 5 items • Yesterday]         |
|                                          |
+------------------------------------------+

// Add to navigation graph
sealed class AutomationScreen(val route: String) {
    object IngestHub : AutomationScreen("automation/hub")
    object QuickAdd : AutomationScreen("automation/quick-add")
    object Scanner : AutomationScreen("automation/scanner")
    object PdfImport : AutomationScreen("automation/pdf-import")
    object Staging : AutomationScreen("automation/staging/{sessionId}") {
        fun createRoute(sessionId: String) = "automation/staging/$sessionId"
    }
}

// Base item - domain agnostic
sealed class Item {
    abstract val id: UUID
    abstract val name: String
    abstract val location: Location
    abstract val gridPosition: GridPosition?
    abstract val sortOrder: Int
    abstract val photoUri: String?
    abstract val domain: ItemDomain  // NEW: Identifies the domain
}

enum class ItemDomain {
    GROCERY,    // Kitchen domain (MVP 1.0)
    CLOTHING,   // Wardrobe domain (Future)
    TOOL,       // Toolbox domain (Future)
    MEDICINE,   // Medicine cabinet (Future)
    GENERAL     // Uncategorized
}

// Domain-specific extensions
data class GroceryItem(...) : Item() {
    override val domain = ItemDomain.GROCERY
    val brand: String?
    val expiryDate: Date?
    val quantity: Double
    val unit: String
    val category: GroceryCategory  // DAIRY, PRODUCE, etc.
}

data class ClothingItem(...) : Item() {  // Future
    override val domain = ItemDomain.CLOTHING
    val size: String?
    val color: String?
    val material: String?
    val category: ClothingCategory  // SHIRT, PANTS, etc.
}

data class ToolItem(...) : Item() {  // Future
    override val domain = ItemDomain.TOOL
    val brand: String?
    val condition: String?
    val category: ToolCategory  // SCREWDRIVER, HAMMER, etc.
}

// Kitchen domain (MVP 1.0)
enum class GroceryCategory {
    DAIRY, PRODUCE, MEAT, FROZEN,
    PANTRY, BEVERAGES, SNACKS, GENERAL
}

// Wardrobe domain (Future)
enum class ClothingCategory {
    SHIRT, TSHIRT, PANTS, SHORTS, DRESS,
    JACKET, SWEATER, UNDERWEAR, SOCKS,
    ACCESSORIES, SHOES, GENERAL
}

// Toolbox domain (Future)
enum class ToolCategory {
    SCREWDRIVER, HAMMER, WRENCH, PLIERS,
    DRILL, SAW, MEASURING, FASTENERS,
    ELECTRICAL, PLUMBING, GENERAL
}

interface DomainRecognizer {
    val domain: ItemDomain
    val supportedInputTypes: List<InputType>

    /**
     * Analyze input and extract items for this domain.
     */
    suspend fun recognize(input: RecognizerInput): RecognitionResult
}

enum class InputType {
    CAMERA_PHOTO,      // Photo of items (wardrobe, toolbox)
    CAMERA_DOCUMENT,   // Document/receipt scan
    PDF_DOCUMENT,      // PDF file
    MANUAL_ENTRY       // User typing
}

// MVP 1.0: Grocery recognizer
class GroceryRecognizer @Inject constructor(
    private val receiptParsers: List<ReceiptParser>,
    private val textRecognizer: TextRecognizer
) : DomainRecognizer {
    override val domain = ItemDomain.GROCERY
    override val supportedInputTypes = listOf(
        InputType.CAMERA_DOCUMENT,
        InputType.PDF_DOCUMENT,
        InputType.MANUAL_ENTRY
    )
    // ...
}

// Future: Clothing recognizer using ML Kit Object Detection
class ClothingRecognizer @Inject constructor(
    private val objectDetector: ObjectDetector
) : DomainRecognizer {
    override val domain = ItemDomain.CLOTHING
    override val supportedInputTypes = listOf(
        InputType.CAMERA_PHOTO,
        InputType.MANUAL_ENTRY
    )
    // Analyze wardrobe photo → detect shirts, pants, etc.
}

@Entity(tableName = "item_templates")
data class ItemTemplateEntity(
    @PrimaryKey val id: String,
    val domain: String,           // ItemDomain enum name
    val canonicalName: String,
    // ... domain-agnostic fields ...

    // Domain-specific defaults stored as JSON
    val domainDefaults: String?   // JSON blob for domain-specific fields
)

// Example domainDefaults for Grocery:
// {"expiryDays": 7, "category": "DAIRY", "unit": "L"}

// Example domainDefaults for Clothing:
// {"category": "SHIRT", "defaultSize": "M"}