Make kit edits incremental: pin existing picks/brand so add/remove doesn't reshuffle the whole bundle

RAG_Products/chat.py

@@ -31,7 +31,7 @@ from RAG_Products.similar import match_product, rank_similar
 from RAG_Products.kits import (
     detect_kit,
     plan_categories,
-    build_kit,
+    build_kit_keep,
     best_single_brand_kit,
 )
 from RAG_Products.usecases import detect_use_case, rank_for_use_case
@@ -488,8 +488,16 @@ def _handle_kit(query, ent):
     return _build_kit_response(query, categories, budget, kit_name)
 
 
-def _build_kit_response(query, categories, budget, kit_name, prefix=None):
-    """Shared kit assembly used by both fresh requests and follow-ups."""
+def _build_kit_response(query, categories, budget, kit_name, prefix=None,
+                         keep_same=None, keep_mixed=None, lock_brand=None):
+    """Shared kit assembly used by both fresh requests and follow-ups.
+
+    `keep_same`/`keep_mixed` (cat -> product name) pin the previous bundle's
+    picks so editing a kit (add/remove a category, change budget) doesn't
+    reshuffle items that were already chosen — only the changed slice is
+    resolved fresh. `lock_brand` keeps the same-brand bundle on the brand it
+    already used.
+    """
     catalog = get_catalog()
     categories = [c for c in categories if c in get_stock_categories()]
     extra = []
@@ -509,17 +517,20 @@ def _build_kit_response(query, categories, budget, kit_name, prefix=None):
             "leftover": (budget - total) if budget else None,
             "items": items,
             "dropped": dropped,
+            "picks": {d.metadata.get("category"): d.metadata.get("name") for d in ordered},
         })
 
     # 1) same-brand bundle first (customer preference)
-    same = best_single_brand_kit(categories, budget, catalog)
+    same = best_single_brand_kit(categories, budget, catalog,
+                                  keep=keep_same, lock_brand=lock_brand)
     if same:
         b_brand, b_ordered, b_total, b_inc, b_dropped = same
         add_block(f"{b_brand} — same-brand bundle", b_brand,
                   b_ordered, b_total, b_inc, b_dropped)
 
     # 2) best-value mixed bundle
-    m_ordered, m_total, m_inc, m_dropped = build_kit(categories, budget, catalog)
+    m_ordered, m_total, m_inc, m_dropped = build_kit_keep(
+        categories, budget, catalog, keep_mixed or {})
     add_block("Best value — mixed brands", None,
               m_ordered, m_total, m_inc, m_dropped)
 
@@ -545,6 +556,11 @@ def _build_kit_response(query, categories, budget, kit_name, prefix=None):
     # conversational memory: remember this kit for follow-ups
     resp["kit_categories"] = categories
     resp["kit_budget"] = budget
+    same_kit = next((k for k in kits if k["brand"]), None)
+    mixed_kit = next((k for k in kits if not k["brand"]), None)
+    resp["kit_picks_same"] = same_kit["picks"] if same_kit else {}
+    resp["kit_picks_mixed"] = mixed_kit["picks"] if mixed_kit else {}
+    resp["kit_brand"] = same_kit["brand"].lower().strip() if same_kit else None
     return resp
 
 
@@ -554,7 +570,8 @@ _TERM_CATEGORY = {
     "audio": "Microphone / Audio", "sound": "Microphone / Audio",
     "camera": "Action Camera", "cam": "Action Camera",
     "action camera": "Action Camera", "gopro": "Action Camera",
-    "gimbal": "Gimbal / Stabilizer", "stabilizer": "Gimbal / Stabilizer",
+    "gimbal": "Gimbal / Stabilizer", "gimble": "Gimbal / Stabilizer",
+    "stabilizer": "Gimbal / Stabilizer", "stabiliser": "Gimbal / Stabilizer",
     "light": "Lighting", "lighting": "Lighting",
     "lens": "Lens", "tripod": "Tripod / Support", "stand": "Tripod / Support",
     "memory": "Memory / Storage", "card": "Memory / Storage", "sd": "Memory / Storage",
@@ -602,6 +619,9 @@ def _handle_kit_followup(query, fu, context):
     op, payload = fu
     categories = list(context.get("kit_categories") or [])
     budget = context.get("kit_budget")
+    keep_same = dict(context.get("kit_picks_same") or {})
+    keep_mixed = dict(context.get("kit_picks_mixed") or {})
+    lock_brand = context.get("kit_brand")
     prefix = None
 
     if op == "add":
@@ -614,15 +634,22 @@ def _handle_kit_followup(query, fu, context):
             prefix = f"Updated kit — added {', '.join(c.lower() for c in added)}"
     elif op == "remove":
         categories = [c for c in categories if c not in payload]
+        for c in payload:
+            keep_same.pop(c, None)
+            keep_mixed.pop(c, None)
         nice = ", ".join(c.lower() for c in payload)
         prefix = f"Updated kit — removed {nice}"
     elif op == "budget":
         budget = payload
         prefix = f"Rebuilt kit for {_money(budget)}"
+        # a budget change can legitimately require reshuffling, so don't pin
+        keep_same, keep_mixed, lock_brand = {}, {}, None
 
     if not categories:
         return _empty(query, "kit", "That would empty the kit — nothing left to build.")
-    return _build_kit_response(query, categories, budget, "updated", prefix=prefix)
+    return _build_kit_response(query, categories, budget, "updated", prefix=prefix,
+                               keep_same=keep_same, keep_mixed=keep_mixed,
+                               lock_brand=lock_brand)
 
 
 def _handle_use_case(query, ent):

RAG_Products/kits.py

@@ -212,12 +212,75 @@ def build_kit(categories, budget, catalog, brand=None):
     return ordered, sum(_price(d) for d in ordered), included, dropped
 
 
-def best_single_brand_kit(categories, budget, catalog):
+def build_kit_keep(categories, budget, catalog, keep, brand=None):
+    """Like build_kit, but pins `keep` (cat -> name) to the SAME product where
+    still possible, only solving freshly for categories not in `keep`.
+
+    This is what makes kit edits incremental: adding a gimbal to a podcast kit
+    must not also swap out the mic/tripod/power that were already chosen.
+    `keep` maps category -> product name to hold fixed across the edit.
+    """
+    def pool_for(cat):
+        items = [d for d in catalog
+                 if d.metadata.get("category") == cat and d.metadata.get("price")]
+        if brand:
+            items = [d for d in items if d.metadata.get("brand_key") == brand]
+        return sorted(items, key=_price)
+
+    by_cat = {c: pool_for(c) for c in categories}
+    available = [c for c in categories if by_cat[c]]
+    if not available:
+        return [], 0, [], list(categories)
+
+    picks = {}
+    locked_total = 0
+    new_cats = []
+    for c in available:
+        kept_name = keep.get(c)
+        found = None
+        if kept_name:
+            found = next((d for d in by_cat[c] if d.metadata.get("name") == kept_name), None)
+        if found:
+            picks[c] = found
+            locked_total += _price(found)
+        else:
+            new_cats.append(c)
+
+    if not new_cats:
+        ordered = [picks[c] for c in categories if c in picks]
+        included = [c for c in categories if c in picks]
+        dropped = [c for c in categories if c not in picks]
+        return ordered, sum(_price(d) for d in ordered), included, dropped
+
+    # solve only the new categories with whatever budget remains
+    remaining = (budget - locked_total) if budget else None
+    if remaining is not None and remaining < 0:
+        remaining = 0
+    new_ordered, _, new_included, new_dropped = build_kit(
+        new_cats, remaining, catalog, brand=brand)
+    for d in new_ordered:
+        picks[d.metadata.get("category")] = d
+
+    ordered = [picks[c] for c in categories if c in picks]
+    included = [c for c in categories if c in picks]
+    dropped = [c for c in categories if c not in picks]
+    return ordered, sum(_price(d) for d in ordered), included, dropped
+
+
+def best_single_brand_kit(categories, budget, catalog, keep=None, lock_brand=None):
     """Find the brand whose products cover the most of the kit, cheapest.
 
+    `keep` (cat -> name) pins already-chosen items so an edit doesn't reshuffle
+    the rest of the bundle. `lock_brand` keeps the bundle on the SAME brand
+    across an edit (e.g. adding a gimbal to a Digitek podcast kit must not
+    swap the whole bundle to a brand that happens to sell gimbals) — if that
+    brand can't cover a newly added category, the category is just left
+    uncovered for this bundle rather than abandoning the brand.
+
     Returns (brand_display, ordered, total, included, dropped) or None if no
     brand covers at least 2 of the categories within budget.
     """
+    keep = keep or {}
     # candidate brands = those present in these categories
     brand_cov = {}
     brand_name = {}
@@ -233,13 +296,25 @@ def best_single_brand_kit(categories, budget, catalog):
     # share of the kit — otherwise it's an incoherent grab-bag.
     min_cover = max(2, (len(categories) + 1) // 2)
 
-    # rank brands by category coverage
+    if lock_brand:
+        # stay on the same brand regardless of new-category coverage; only
+        # the categories that brand actually stocks get filled in.
+        covers = brand_cov.get(lock_brand, set())
+        if not covers:
+            return None
+        ordered, total, included, dropped = build_kit_keep(
+            categories, budget, catalog, keep, brand=lock_brand)
+        if not included:
+            return None
+        return (brand_name.get(lock_brand, lock_brand), ordered, total, included, dropped)
+
     ranked = sorted(brand_cov.items(), key=lambda kv: len(kv[1]), reverse=True)
     best = None
     for bk, covers in ranked:
         if len(covers) < min_cover:
             break
-        ordered, total, included, dropped = build_kit(categories, budget, catalog, brand=bk)
+        ordered, total, included, dropped = build_kit_keep(
+            categories, budget, catalog, keep, brand=bk)
         if len(included) < min_cover:
             continue
         cand = (brand_name[bk], ordered, total, included, dropped)