Fix spice handling in shopping list and Bring sync

Shopping list + Bring sync:
- Spices (category='Gewürze') with quantity > 0: always 'in stock' regardless
  of unit mismatch (recipe says 3g, inventory says 100% = still available)
- Spices not in inventory or empty: added as '1 Packung' (not raw grams)
- Min-stock for spices: shows as '1 Packung' when depleted
- Bring service: same logic, also fixed old crude includes() matching

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: JiroMusik

server.ts

@@ -407,10 +407,10 @@ app.get('/api/shopping-list', (req, res) => {
       });
     });
 
-    const inventory = db.prepare('SELECT name, generic_name, quantity, unit, min_stock FROM items WHERE quantity > 0').all() as any[];
+    const inventory = db.prepare('SELECT name, generic_name, quantity, unit, min_stock, category FROM items WHERE quantity > 0').all() as any[];
 
     // Add items that are below minimum stock
-    const allKnownItems = db.prepare('SELECT name, generic_name, quantity, unit, min_stock FROM items').all() as any[];
+    const allKnownItems = db.prepare('SELECT name, generic_name, quantity, unit, min_stock, category FROM items').all() as any[];
     const lowStockItems: Record<string, { amount: number, unit: string, name: string }> = {};
 
     // Group by name and unit for min_stock check
@@ -424,21 +424,41 @@ app.get('/api/shopping-list', (req, res) => {
       stockLevels[key].total += smallest.amount;
     });
 
+    // Min-stock: for spices show as "1 Packung", for others show deficit amount
     Object.entries(stockLevels).forEach(([key, level]) => {
       if (level.min > 0 && level.total < level.min) {
         const name = key.split('_')[0];
-        const missing = level.min - level.total;
-        if (!required[key]) {
-          required[key] = { amount: 0, unit: level.unit, name: name.charAt(0).toUpperCase() + name.slice(1) };
+        const item = allKnownItems.find(i => i.name.toLowerCase() === name);
+        if (item?.category === 'Gewürze') {
+          // Spices: add as "1 Packung"
+          const spiceKey = `${name}_Stück`;
+          if (!required[spiceKey]) {
+            required[spiceKey] = { amount: 0, unit: 'Stück', name: name.charAt(0).toUpperCase() + name.slice(1) };
+          }
+          required[spiceKey].amount = 1;
+        } else {
+          const missing = level.min - level.total;
+          if (!required[key]) {
+            required[key] = { amount: 0, unit: level.unit, name: name.charAt(0).toUpperCase() + name.slice(1) };
+          }
+          required[key].amount += missing;
         }
-        required[key].amount += missing;
       }
     });
 
     const missingIngredients: any[] = [];
 
     Object.values(required).forEach((reqIng: any) => {
-      // Use canonical alias matching (same as recipe ingredient checking)
+      // Spices: if any matching item exists with quantity > 0, it's available (regardless of unit mismatch g vs %)
+      const anyMatchInInventory = inventory.some(inv => isIngredientInInventory(reqIng.name, [inv]));
+      if (anyMatchInInventory) {
+        const matchedItem = inventory.find(inv => isIngredientInInventory(reqIng.name, [inv]));
+        if (matchedItem?.category === 'Gewürze' && matchedItem.quantity > 0) {
+          return; // Spice is in stock, skip
+        }
+      }
+
+      // Standard matching with unit awareness
       const matchingItems = inventory.filter(inv => {
         if (!isIngredientInInventory(reqIng.name, [inv])) return false;
         const invSmallest = convertToSmallestUnit(inv.quantity, inv.unit);

server/services/bring.service.ts

@@ -3,6 +3,9 @@ import Bring from 'bring-shopping';
 import { db } from '../db/database';
 import { convertToSmallestUnit, normalizeUnit } from '../utils/units';
 
+// Import isIngredientInInventory from server.ts is circular — inline a simple version
+const normalizeIngredient = (s: string) => s.toLowerCase().replace(/\(.*?\)/g, '').replace(/[,\.]/g, '').replace(/\s+/g, ' ').trim();
+
 const getBringClient = () => {
   const emailRow = db.prepare('SELECT value FROM settings WHERE key = ?').get('bring_email') as any;
   const passRow = db.prepare('SELECT value FROM settings WHERE key = ?').get('bring_password') as any;
@@ -18,13 +21,13 @@ export const syncToBring = async () => {
     await bring.login();
     const lists = await bring.loadLists();
     if (!lists || lists.lists.length === 0) return;
-    
+
     const listId = lists.lists[0].listUuid;
     const bringItems = await bring.getItems(listId);
-    
+
     const today = new Date().toISOString().split('T')[0];
     const upcomingRecipes = db.prepare('SELECT * FROM planned_recipes WHERE date >= ? AND cooked = 0').all(today);
-    
+
     const required: Record<string, { amount: number, unit: string, name: string }> = {};
     upcomingRecipes.forEach((recipe: any) => {
       const ingredients = JSON.parse(recipe.ingredients);
@@ -39,36 +42,61 @@ export const syncToBring = async () => {
       });
     });
 
-    const inventory = db.prepare('SELECT name, quantity, unit, min_stock FROM items WHERE quantity > 0').all() as any[];
-    const allKnownItems = db.prepare('SELECT name, quantity, unit, min_stock FROM items').all() as any[];
-    
-    const stockLevels: Record<string, { total: number, min: number, unit: string }> = {};
+    const inventory = db.prepare('SELECT name, generic_name, quantity, unit, min_stock, category FROM items WHERE quantity > 0').all() as any[];
+    const allKnownItems = db.prepare('SELECT name, generic_name, quantity, unit, min_stock, category FROM items').all() as any[];
+
+    // Min-stock requirements
+    const stockLevels: Record<string, { total: number, min: number, unit: string, category: string, name: string }> = {};
     allKnownItems.forEach(item => {
       const key = `${item.name.toLowerCase()}_${normalizeUnit(item.unit)}`;
       if (!stockLevels[key]) {
-        stockLevels[key] = { total: 0, min: item.min_stock || 0, unit: normalizeUnit(item.unit) };
+        stockLevels[key] = { total: 0, min: item.min_stock || 0, unit: normalizeUnit(item.unit), category: item.category, name: item.name };
       }
       const smallest = convertToSmallestUnit(item.quantity, item.unit);
       stockLevels[key].total += smallest.amount;
     });
 
     Object.entries(stockLevels).forEach(([key, level]) => {
       if (level.min > 0 && level.total < level.min) {
-        const name = key.split('_')[0];
-        const missing = level.min - level.total;
-        if (!required[key]) {
-          required[key] = { amount: 0, unit: level.unit, name: name.charAt(0).toUpperCase() + name.slice(1) };
+        if (level.category === 'Gewürze') {
+          // Spices: "1 Packung"
+          const spiceKey = `${level.name.toLowerCase()}_Stück`;
+          if (!required[spiceKey]) {
+            required[spiceKey] = { amount: 1, unit: 'Stück', name: level.name };
+          }
+        } else {
+          const missing = level.min - level.total;
+          if (!required[key]) {
+            required[key] = { amount: 0, unit: level.unit, name: level.name };
+          }
+          required[key].amount += missing;
         }
-        required[key].amount += missing;
       }
     });
 
     const missingNames = new Set<string>();
     Object.values(required).forEach((reqIng: any) => {
+      // Spices: if in inventory with quantity > 0, always consider available
+      const matchedInv = inventory.find(inv => {
+        const invNorm = normalizeIngredient(inv.name);
+        const genNorm = inv.generic_name ? normalizeIngredient(inv.generic_name) : '';
+        const reqNorm = normalizeIngredient(reqIng.name);
+        return invNorm.includes(reqNorm) || reqNorm.includes(invNorm) ||
+               genNorm.includes(reqNorm) || reqNorm.includes(genNorm);
+      });
+
+      if (matchedInv?.category === 'Gewürze' && matchedInv.quantity > 0) {
+        return; // Spice in stock, skip
+      }
+
+      // Standard unit-aware matching
       const matchingItems = inventory.filter(inv => {
-        const isNameMatch = inv.name.toLowerCase().includes(reqIng.name.toLowerCase()) || 
-                          reqIng.name.toLowerCase().includes(inv.name.toLowerCase());
-        if (!isNameMatch) return false;
+        const invNorm = normalizeIngredient(inv.name);
+        const genNorm = inv.generic_name ? normalizeIngredient(inv.generic_name) : '';
+        const reqNorm = normalizeIngredient(reqIng.name);
+        const nameMatch = invNorm.includes(reqNorm) || reqNorm.includes(invNorm) ||
+                         genNorm.includes(reqNorm) || reqNorm.includes(genNorm);
+        if (!nameMatch) return false;
         const invSmallest = convertToSmallestUnit(inv.quantity, inv.unit);
         return invSmallest.unit === reqIng.unit;
       });
@@ -83,6 +111,7 @@ export const syncToBring = async () => {
       }
     });
 
+    // ONE-WAY SYNC: add missing, remove no-longer-missing known items
     const bringCurrentNames = new Set(bringItems.purchase.map((i: any) => i.name.toLowerCase()));
     for (const missingName of missingNames) {
       if (!bringCurrentNames.has(missingName)) {