Update main.py

main.py

@@ -1,11 +1,11 @@
 """
-main.py — Pricelyst Shopping Advisor (Jessica Edition 2026 - Upgrade v2.7)
+main.py — Pricelyst Shopping Advisor (Jessica Edition 2026 - Upgrade v3.0)
 
-✅ Fixed: Basket Comparison (Compares totals across ALL stores, showing missing items).
-✅ Fixed: Brand Loyalty (Explicitly states if exact brand is missing & suggests closest).
-✅ Logic: "Market Matrix" calculates basket cost for every retailer found.
-✅ "Analyst Engine": Enhanced Data Flattening & Comparison Logic.
-✅ "Visual Engine": Lists, Products, & Meal-to-Recipe recognition.
+✅ Feature: "Concept Exploder" (Converts "Plan a Braai" -> Shopping List).
+✅ Feature: "Hybrid Valuation" (Estimates prices for missing items in Plans).
+✅ Feature: "Market Intelligence" (Pre-calculated Voice Context).
+✅ UI Match: Restored v1 Markdown Tables & Creative Tips.
+✅ Core: Deep Vector Search + Market Matrix + Store Preferences.
 
 ENV VARS:
 - GOOGLE_API_KEY=...
@@ -94,7 +94,7 @@ ZIM_CONTEXT = {
     "fuel_petrol": 1.58,
     "fuel_diesel": 1.65,
     "gas_lpg": 2.00,
-    "bread_avg": 1.00,
+    "bread_avg": 1.10,
     "zesa_step_1": {"limit": 50, "rate": 0.04},
     "zesa_step_2": {"limit": 150, "rate": 0.09},
     "zesa_step_3": {"limit": 9999, "rate": 0.14},
@@ -236,7 +236,7 @@ def get_market_index(force_refresh: bool = False) -> pd.DataFrame:
     return _data_cache["df"]
 
 # =========================
-# 2. Analyst Engine (Matrix & Fallbacks)
+# 2. Analyst Engine (Matrix & Calculations)
 # =========================
 
 def search_products_deep(df: pd.DataFrame, query: str, limit: int = 15) -> pd.DataFrame:
@@ -288,19 +288,16 @@ def calculate_basket_optimization(item_names: List[str], preferred_retailer: str
         best_match = hits.iloc[0]
         
         # --- Brand Fidelity Check ---
-        # Did the user ask for "Top Chef" but we got "Mega Basmati"?
         q_norm = _norm(item)
         res_norm = _norm(best_match['product_name'] + " " + best_match['brand'])
-        
-        # Simple heuristic: If query has 2+ words, and <50% of them are in result, it's a sub.
         q_tokens = q_norm.split()
         is_substitute = False
         if len(q_tokens) > 1:
             found_tokens = sum(1 for t in q_tokens if t in res_norm)
-            if found_tokens < len(q_tokens) / 2: # Loose threshold
+            if found_tokens < len(q_tokens) / 2: 
                 is_substitute = True
                 
-        # Aggregate all offers for this specific product ID
+        # Aggregate all offers
         product_offers = hits[hits['product_name'] == best_match['product_name']].sort_values('price')
         
         offers_list = []
@@ -310,7 +307,7 @@ def calculate_basket_optimization(item_names: List[str], preferred_retailer: str
         found_items.append({
             "query": item,
             "product_name": str(best_match['product_name']),
-            "is_substitute": is_substitute, # KEY FEATURE
+            "is_substitute": is_substitute,
             "offers": offers_list,
             "best_price": offers_list[0]['price']
         })
@@ -319,7 +316,6 @@ def calculate_basket_optimization(item_names: List[str], preferred_retailer: str
         return {"actionable": True, "found_items": [], "global_missing": missing_global}
 
     # 2. MARKET MATRIX (Comparison across all stores)
-    # Get unique retailers involved in these products
     all_involved_retailers = set()
     for f in found_items:
         for o in f['offers']:
@@ -333,7 +329,6 @@ def calculate_basket_optimization(item_names: List[str], preferred_retailer: str
         missing_in_store = []
         
         for item in found_items:
-            # Find price at this retailer
             price = next((o['price'] for o in item['offers'] if o['retailer'] == retailer), None)
             if price:
                 total_price += price
@@ -349,7 +344,6 @@ def calculate_basket_optimization(item_names: List[str], preferred_retailer: str
             "missing_items": missing_in_store
         })
 
-    # Sort Matrix: Most Items Found -> Lowest Price
     store_comparison.sort(key=lambda x: (-x['found_count'], x['total_price']))
     
     return {
@@ -357,7 +351,7 @@ def calculate_basket_optimization(item_names: List[str], preferred_retailer: str
         "is_basket": len(found_items) > 1,
         "found_items": found_items,
         "global_missing": missing_global,
-        "market_matrix": store_comparison[:4], # Top 4 comparison
+        "market_matrix": store_comparison[:4], 
         "best_store": store_comparison[0] if store_comparison else None,
         "preferred_retailer": preferred_retailer
     }
@@ -365,7 +359,6 @@ def calculate_basket_optimization(item_names: List[str], preferred_retailer: str
 def calculate_zesa_units(amount_usd: float) -> Dict[str, Any]:
     remaining = amount_usd / 1.06 
     units = 0.0
-    breakdown = []
     
     t1 = ZIM_CONTEXT["zesa_step_1"]
     cost_t1 = t1["limit"] * t1["rate"]
@@ -373,7 +366,6 @@ def calculate_zesa_units(amount_usd: float) -> Dict[str, Any]:
     if remaining > cost_t1:
         units += t1["limit"]
         remaining -= cost_t1
-        breakdown.append(f"First {t1['limit']}u @ ${t1['rate']}")
         
         t2 = ZIM_CONTEXT["zesa_step_2"]
         cost_t2 = t2["limit"] * t2["rate"]
@@ -381,30 +373,19 @@ def calculate_zesa_units(amount_usd: float) -> Dict[str, Any]:
         if remaining > cost_t2:
             units += t2["limit"]
             remaining -= cost_t2
-            breakdown.append(f"Next {t2['limit']}u @ ${t2['rate']}")
-            
-            t3 = ZIM_CONTEXT["zesa_step_3"]
-            bought = remaining / t3["rate"]
-            units += bought
-            breakdown.append(f"Balance -> {bought:.1f}u @ ${t3['rate']}")
+            units += remaining / ZIM_CONTEXT["zesa_step_3"]["rate"]
         else:
-            bought = remaining / t2["rate"]
-            units += bought
-            breakdown.append(f"Balance -> {bought:.1f}u @ ${t2['rate']}")
+            units += remaining / t2["rate"]
     else:
-        bought = remaining / t1["rate"]
-        units += bought
-        breakdown.append(f"All {bought:.1f}u @ ${t1['rate']}")
+        units += remaining / t1["rate"]
 
     return {
         "amount_usd": float(amount_usd),
-        "est_units_kwh": float(round(units, 1)),
-        "breakdown": breakdown,
-        "note": "Includes approx 6% REA levy deduction."
+        "est_units_kwh": float(round(units, 1))
     }
 
 # =========================
-# 3. Gemini Helpers
+# 3. Gemini Helpers (The Intelligence)
 # =========================
 
 def gemini_detect_intent(transcript: str) -> Dict[str, Any]:
@@ -417,11 +398,13 @@ def gemini_detect_intent(transcript: str) -> Dict[str, Any]:
     - SHOPPING_BASKET: Looking for prices, products, "cheapest X".
     - UTILITY_CALC: Electricity/ZESA questions.
     - STORE_DECISION: "Where should I buy?", "Which store is cheapest?".
+    - EVENT_PLANNING: "Plan a braai", "Wedding list", "Dinner for 5" (Implicit lists).
     
     Extract:
-    - items: list of products found.
+    - items: list of specific products found.
     - utility_amount: number
     - store_preference: if a specific store is named (e.g. "at OK Mart").
+    - is_event_planning: boolean (true if user asks to plan an event but lists no items).
     
     JSON Schema:
     {
@@ -429,7 +412,8 @@ def gemini_detect_intent(transcript: str) -> Dict[str, Any]:
       "intent": "string",
       "items": ["string"],
       "utility_amount": number,
-      "store_preference": "string"
+      "store_preference": "string",
+      "is_event_planning": boolean
     }
     """
     try:
@@ -443,6 +427,29 @@ def gemini_detect_intent(transcript: str) -> Dict[str, Any]:
         logger.error(f"Intent Detect Error: {e}")
         return {"actionable": False, "intent": "CASUAL_CHAT"}
 
+def gemini_explode_concept(transcript: str) -> List[str]:
+    """
+    Converts a concept ("Braai for 10") into a concrete list ("Wors", "Charcoal").
+    """
+    if not _gemini_client: return []
+    
+    PROMPT = f"""
+    User wants to plan an event: "{transcript}".
+    Generate a STRICT list of 10-15 essential Zimbabwean shopping items for this.
+    Use local terms (e.g., 'Boerewors', 'Maize Meal', 'Mazoe', 'Charcoal').
+    Return ONLY a JSON list of strings.
+    """
+    try:
+        resp = _gemini_client.models.generate_content(
+            model=GEMINI_MODEL,
+            contents=PROMPT,
+            config=types.GenerateContentConfig(response_mime_type="application/json")
+        )
+        return _safe_json_loads(resp.text, [])
+    except Exception as e:
+        logger.error(f"Explode Concept Error: {e}")
+        return []
+
 def gemini_analyze_image(image_b64: str, caption: str = "") -> Dict[str, Any]:
     if not _gemini_client: return {"error": "AI Offline"}
     
@@ -497,18 +504,15 @@ def gemini_chat_response(transcript: str, intent: Dict, analyst_data: Dict, chat
     
     LOGIC RULES:
     
-    1. **BASKET COMPARISON (Transparency)**:
-       - If `market_matrix` has multiple stores, **COMPARE THEM**.
-       - Example: "Spar is **$6.95** (All items). OK Mart is **$4.00**, but misses Cooking Oil."
-       - Don't just show the winner. Show the ecosystem.
+    1. **BASKET COMPARISON**:
+       - If `market_matrix` has multiple stores, compare totals.
+       - "Spar is **$6.95**, OK Mart is **$4.00** (but missing Oil)."
 
-    2. **BRAND LOYALTY (Graceful Fallback)**:
-       - If `is_substitute` is TRUE for an item, say: 
-         "I couldn't find **[Query Brand]** exactly, so I've used **[Found Product]** ($Price) as a placeholder."
-       - Be honest about brand mismatches.
+    2. **BRAND SUBSTITUTES**:
+       - If `is_substitute` is TRUE: "I couldn't find **[Query]**, so I used **[Found]** ($Price) as a placeholder."
 
     3. **SINGLE ITEMS**:
-       - Best price first, then list 1-2 others.
+       - Best price first, then others.
 
     4. **CASUAL**:
        - Reset if user says "Hi".
@@ -531,12 +535,32 @@ def gemini_generate_4step_plan(transcript: str, analyst_result: Dict) -> str:
 
     PROMPT = f"""
     Generate a formatted Markdown Shopping Plan.
+    
+    USER REQUEST: "{transcript}"
     DATA: {json.dumps(analyst_result, indent=2, default=str)}
+    
+    CRITICAL INSTRUCTION:
+    For items in 'global_missing', you MUST provide a Realistic USD Estimate (e.g. Chicken ~$6.00).
+    Do not leave them as "Unknown".
+    
     SECTIONS:
-    1. **Catalogue Found ✅** (Table: Item | Store | Price)
-    2. **Missing/Substitutes ⚠️** (Be clear about brand swaps)
-    3. **Store Comparison 📊** (List the Top 3 stores totals)
-    4. **Recommendation 💡**
+    
+    1. **In Our Catalogue ✅** 
+       (Markdown Table: | Item | Retailer | Price (USD) |)
+    
+    2. **Not in Catalogue (Estimates) 😔**
+       (Markdown Table: | Item | Estimated Price (USD) |)
+       *Fill in estimated prices for missing items based on Zimbabwe market knowledge.*
+       
+    3. **Totals 💰**
+       - Confirmed Total (Catalogue)
+       - Estimated Total (Missing Items)
+       - **Grand Total Estimate**
+       
+    4. **Ideas & Tips 💡**
+       - 3 Creative ideas based on the specific event/meal (e.g. Braai tips, Cooking hacks).
+    
+    Tone: Warm, Professional, Zimbabwean.
     """
     try:
         resp = _gemini_client.models.generate_content(model=GEMINI_MODEL, contents=PROMPT)
@@ -555,7 +579,7 @@ def health():
         "ok": True,
         "offers_indexed": len(df),
         "api_source": PRICE_API_BASE,
-        "persona": "Jessica v2.7 (Matrix & Loyalty)"
+        "persona": "Jessica v3.0 (Event Planner)"
     })
 
 @app.post("/chat")
@@ -651,35 +675,87 @@ def analyze_image():
 
 @app.post("/api/call-briefing")
 def call_briefing():
-    # ... (Same as before)
+    """
+    Injects INTELLIGENT Market Data into the Voice Bot's context.
+    Includes: Staples Index, ZESA/Fuel, Top 60 Catalogue.
+    """
     body = request.get_json(silent=True) or {}
     pid = body.get("profile_id")
-    username = body.get("username")
+    username = body.get("username", "Friend")
+    
     if not pid: return jsonify({"ok": False}), 400
+    
+    # 1. Memory Profile
     prof = {}
     if db:
         ref = db.collection("pricelyst_profiles").document(pid)
         doc = ref.get()
         if doc.exists: prof = doc.to_dict()
         else: ref.set({"created_at": datetime.now(timezone.utc).isoformat()})
-    if username and username != prof.get("username"):
+    
+    if username != "Friend" and username != prof.get("username"):
         if db: db.collection("pricelyst_profiles").document(pid).set({"username": username}, merge=True)
+
+    # 2. Market Intelligence Generation
     df = get_market_index()
-    catalogue_str = ""
+    market_intel = ""
+    
+    # A. ZESA & Fuel
+    zesa_10 = calculate_zesa_units(10.0)
+    zesa_20 = calculate_zesa_units(20.0)
+    
+    context_section = f"""
+    [CRITICAL CONTEXT - ZIMBABWE]
+    FUEL: Petrol=${ZIM_CONTEXT['fuel_petrol']}, Diesel=${ZIM_CONTEXT['fuel_diesel']}
+    BREAD: ~${ZIM_CONTEXT['bread_avg']}
+    ZESA (Electricity): $10 = {zesa_10['est_units_kwh']}u, $20 = {zesa_20['est_units_kwh']}u
+    """
+    
+    # B. Staples Index
+    staples = ["Cooking Oil", "Maize Meal", "Sugar", "Rice"]
+    staple_summary = []
+    
+    if not df.empty:
+        for s in staples:
+            hits = search_products_deep(df[df['is_offer']==True], s, limit=5)
+            if not hits.empty:
+                cheapest = hits.sort_values('price').iloc[0]
+                staple_summary.append(f"- {s}: ${cheapest['price']} @ {cheapest['retailer']}")
+    
+    staples_section = "\n[STAPLES - LOWEST]\n" + "\n".join(staple_summary)
+    
+    # C. Top 60 Catalogue
+    catalogue_lines = []
     if not df.empty:
-        top = df[df['is_offer']].sort_values('views', ascending=False).drop_duplicates('product_name').head(60)
-        lines = [f"{r['product_name']} (~${r['price']:.2f})" for _, r in top.iterrows()]
-        catalogue_str = ", ".join(lines)
-    kpi_snapshot = {"market_rates": ZIM_CONTEXT, "popular_products": catalogue_str}
-    return jsonify({"ok": True, "memory_summary": prof.get("memory_summary", ""), "kpi_snapshot": json.dumps(kpi_snapshot)})
+        top_items = df[df['is_offer']==True].sort_values('views', ascending=False).drop_duplicates('product_name').head(60)
+        for _, r in top_items.iterrows():
+            p_name = r['product_name']
+            all_offers = df[(df['product_name'] == p_name) & df['is_offer']]
+            prices_str = ", ".join([f"${o['price']} ({o['retailer']})" for _, o in all_offers.iterrows()])
+            catalogue_lines.append(f"- {p_name}: {prices_str}")
+            
+    catalogue_section = "\n[CATALOGUE - TOP 60]\n" + "\n".join(catalogue_lines)
+    
+    return jsonify({
+        "ok": True,
+        "username": username,
+        "memory_summary": prof.get("memory_summary", ""),
+        "kpi_snapshot": context_section + staples_section + catalogue_section
+    })
 
 @app.post("/api/log-call-usage")
 def log_call_usage():
-    # ... (Same as before)
+    """
+    Post-Call Orchestrator.
+    v3.0 Upgrade: Handles Concept Explosion for Event Planning.
+    """
     body = request.get_json(silent=True) or {}
     pid = body.get("profile_id")
     transcript = body.get("transcript", "")
+    
     if not pid: return jsonify({"ok": False}), 400
+    
+    # 1. Update Long-Term Memory
     if len(transcript) > 20 and db:
         try:
             curr_mem = db.collection("pricelyst_profiles").document(pid).get().to_dict().get("memory_summary", "")
@@ -687,27 +763,59 @@ def log_call_usage():
             mem_resp = _gemini_client.models.generate_content(model=GEMINI_MODEL, contents=mem_prompt)
             db.collection("pricelyst_profiles").document(pid).set({"memory_summary": mem_resp.text}, merge=True)
         except: pass
+
+    # 2. Plan Generation Logic
     intent_data = gemini_detect_intent(transcript)
     plan_data = {}
-    if intent_data.get("actionable") and intent_data.get("items"):
-        analyst_result = calculate_basket_optimization(intent_data["items"])
-        if analyst_result.get("actionable"):
+    
+    # Check if ACTIONABLE (Shopping or Event)
+    if intent_data.get("actionable"):
+        target_items = intent_data.get("items", [])
+        
+        # LOGIC: If Event Planning + No specific items -> EXPLODE CONCEPT
+        if intent_data.get("is_event_planning") and not target_items:
+            logger.info("💥 Exploding Concept for Event...")
+            target_items = gemini_explode_concept(transcript)
+            
+        if target_items:
+            analyst_result = calculate_basket_optimization(target_items)
+            
+            # v3.0: Even if missing items, we generate plan because prompt will ESTIMATE them
             md_content = gemini_generate_4step_plan(transcript, analyst_result)
-            plan_data = {"is_actionable": True, "title": f"Plan {datetime.now().strftime('%d %b')}", "markdown_content": md_content, "items": intent_data["items"], "created_at": datetime.now(timezone.utc).isoformat()}
+            
+            plan_data = {
+                "is_actionable": True,
+                "title": f"Plan ({datetime.now().strftime('%d %b')})",
+                "markdown_content": md_content,
+                "items": target_items,
+                "created_at": datetime.now(timezone.utc).isoformat()
+            }
+            
             if db:
                 doc_ref = db.collection("pricelyst_profiles").document(pid).collection("shopping_plans").document()
                 plan_data["id"] = doc_ref.id
                 doc_ref.set(plan_data)
+
     if db:
-        db.collection("pricelyst_profiles").document(pid).collection("call_logs").add({"transcript": transcript, "intent": intent_data, "plan_generated": bool(plan_data), "ts": datetime.now(timezone.utc).isoformat()})
-    return jsonify({"ok": True, "shopping_plan": plan_data if plan_data.get("is_actionable") else None})
+        db.collection("pricelyst_profiles").document(pid).collection("call_logs").add({
+            "transcript": transcript,
+            "intent": intent_data,
+            "plan_generated": bool(plan_data),
+            "ts": datetime.now(timezone.utc).isoformat()
+        })
+
+    return jsonify({
+        "ok": True,
+        "shopping_plan": plan_data if plan_data.get("is_actionable") else None
+    })
 
 @app.get("/api/shopping-plans")
 def list_plans():
     pid = request.args.get("profile_id")
     if not pid or not db: return jsonify({"ok": False}), 400
     try:
-        docs = db.collection("pricelyst_profiles").document(pid).collection("shopping_plans").order_by("created_at", direction=firestore.Query.DESCENDING).limit(10).stream()
+        docs = db.collection("pricelyst_profiles").document(pid).collection("shopping_plans") \
+                 .order_by("created_at", direction=firestore.Query.DESCENDING).limit(10).stream()
         return jsonify({"ok": True, "plans": [{"id": d.id, **d.to_dict()} for d in docs]})
     except: return jsonify({"ok": False}), 500