Huge Commit of the code that was known working on the front-end.

README.md

@@ -1,10 +1,14 @@
 ---
-title: Agentic-Chat-bot
+title: Store Front Agentic Chat Bot
 emoji: 💬
 colorFrom: indigo
 colorTo: blue
 sdk: gradio
 sdk_version: "4.38.0"
-app_file: space_app.py
+app_file: app_storefront.py
 pinned: false
+license: mit
+short_description: Test for the project front-end.
 ---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app_storefront.py

@@ -0,0 +1,212 @@
+# app_storefront.py
+import os
+import sys
+import gradio as gr
+
+# Ensure "core/" is importable
+sys.path.append(os.path.join(os.path.dirname(__file__), "core"))
+
+# Import only functions; core.storefront doesn't export constants
+from core.model import model_generate, MODEL_NAME
+from core.memory import build_prompt_from_history
+from core.storefront import load_storefront, storefront_qna, extract_products, get_rules
+from core.storefront import is_storefront_query
+
+def chat_pipeline(history, message, max_new_tokens=96, temperature=0.7, top_p=0.9):
+    # 1) Try storefront facts first
+    sf = storefront_qna(DATA, message)
+    if sf:
+        return sf
+
+    # 2) If not a storefront query, offer guided help (no LLM)
+    if not is_storefront_query(message):
+        return (
+            "I can help with the graduation storefront. Examples:\n"
+            "- Parking rules, lots opening times\n"
+            "- Attire / dress code\n"
+            "- Cap & Gown details and pickup\n"
+            "- Parking passes (multiple allowed)\n"
+            "Ask one of those, and I’ll answer directly."
+        )
+
+    # 3) Otherwise, generate with memory and hard stops
+    prompt = build_prompt_from_history(history, message, k=4)
+    gen = model_generate(prompt, max_new_tokens, temperature, top_p)
+    return clean_generation(gen)
+
+def clean_generation(text: str) -> str:
+    return (text or "").strip()
+
+# ---------------- Load data + safe fallbacks ----------------
+DATA = load_storefront()  # may be None if storefront_data.json missing/empty
+
+# Fallbacks used if JSON not present
+FALLBACK_PRODUCTS = [
+    {"sku": "CG-SET", "name": "Cap & Gown Set", "price": 59.00,
+     "notes": "Tassel included; ships until 10 days before the event"},
+    {"sku": "PK-1",   "name": "Parking Pass",   "price": 10.00,
+     "notes": "Multiple passes are allowed per student"}
+]
+FALLBACK_VENUE = [
+    "Formal attire recommended (not required).",
+    "No muscle shirts.",
+    "No sagging pants."
+]
+FALLBACK_PARKING = [
+    "No double parking.",
+    "Vehicles parked in handicap spaces will be towed."
+]
+
+# Normalize products/rules for the tabs
+if DATA:
+    PRODUCTS = extract_products(DATA) or FALLBACK_PRODUCTS
+    venue_rules, parking_rules = get_rules(DATA)
+    VENUE_RULES = venue_rules or FALLBACK_VENUE
+    PARKING_RULES = parking_rules or FALLBACK_PARKING
+else:
+    PRODUCTS = FALLBACK_PRODUCTS
+    VENUE_RULES = FALLBACK_VENUE
+    PARKING_RULES = FALLBACK_PARKING
+
+
+
+# ---------------- UI ----------------
+CSS = """
+:root { --bg:#0b0d12; --panel:#0f172a; --border:#1f2940; --text:#e5e7eb; --muted:#9ca3af; }
+.gradio-container { background: var(--bg) !important; color: var(--text) !important; }
+.panel { border:1px solid var(--border); border-radius:16px; background:var(--panel); }
+.small { font-size:12px; color: var(--muted); }
+"""
+
+with gr.Blocks(title="Storefront Chat", css=CSS) as demo:
+    gr.Markdown("## Storefront Chat")
+
+    # Single history state (kept in sync with Chatbot)
+    history_state = gr.State([])
+
+    with gr.Tabs():
+        # --- TAB: Chat ---
+        with gr.TabItem("Chat"):
+            with gr.Group(elem_classes=["panel"]):
+                chat = gr.Chatbot(height=360, bubble_full_width=False, label="Chat")
+
+                with gr.Row():
+                    msg  = gr.Textbox(placeholder="Ask about parking rules, attire, cap & gown, pickup times…", scale=5)
+                    send = gr.Button("Send", scale=1)
+
+                # Quick chips
+                with gr.Row():
+                    chip1 = gr.Button("Parking rules", variant="secondary")
+                    chip2 = gr.Button("Multiple passes", variant="secondary")
+                    chip3 = gr.Button("Attire", variant="secondary")
+                    chip4 = gr.Button("When do lots open?", variant="secondary")
+
+                # Advanced options (sliders + Health/Capabilities)
+                with gr.Accordion("Advanced chat options", open=False):
+                    max_new = gr.Slider(32, 512, 128, 1, label="Max new tokens")
+                    temp    = gr.Slider(0.1, 1.5, 0.8, 0.05, label="Temperature")
+                    topp    = gr.Slider(0.1, 1.0, 0.95, 0.05, label="Top-p")
+
+                    with gr.Row():
+                        health_btn = gr.Button("Health", variant="secondary")
+                        caps_btn   = gr.Button("Capabilities", variant="secondary")
+                        status_md  = gr.Markdown("Status: not checked", elem_classes=["small"])
+
+        # --- TAB: Products ---
+        with gr.TabItem("Products"):
+            gr.Markdown("### Available Items")
+            cols = ["sku", "name", "price", "notes"]
+            data = [[p.get(c, "") for c in cols] for p in PRODUCTS]
+            gr.Dataframe(headers=[c.upper() for c in cols], value=data, interactive=False, wrap=True, label="Products")
+
+        # --- TAB: Rules ---
+        with gr.TabItem("Rules"):
+            gr.Markdown("### Venue rules")
+            gr.Markdown("- " + "\n- ".join(VENUE_RULES))
+            gr.Markdown("### Parking rules")
+            gr.Markdown("- " + "\n- ".join(PARKING_RULES))
+
+        # --- TAB: Logistics ---
+        with gr.TabItem("Logistics"):
+            gr.Markdown(
+                "### Event Logistics\n"
+                "- Shipping available until 10 days before event (typ. 3–5 business days)\n"
+                "- Pickup: Student Center Bookstore during the week prior to event\n"
+                "- Graduates arrive 90 minutes early; guests 60 minutes early\n"
+                "- Lots A & B open 2 hours before; overflow as needed\n"
+                "\n*Try asking the bot:* “What time should I arrive?” • “Where do I pick up the gown?”"
+            )
+
+    # ---------- Helpers ----------
+    def _append_bot_md(history, md_text):
+        history = history or []
+        return history + [[None, md_text]]
+
+    # ---------- Callbacks ----------
+    def on_send(history, message, max_new_tokens, temperature, top_p):
+        t = (message or "").strip()
+        if not t:
+            return history, history, ""  # no-op; shapes must match
+        history = (history or []) + [[t, None]]
+        reply = chat_pipeline(history[:-1], t, max_new_tokens, temperature, top_p)
+        history[-1][1] = reply
+        return history, history, ""
+
+    def _health_cb(history):
+        md = (
+            f"### Status: ✅ Healthy\n"
+            f"- Model: `{MODEL_NAME}`\n"
+            f"- Storefront JSON: {'loaded' if bool(DATA) else 'not found'}"
+        )
+        new_hist = _append_bot_md(history, md)
+        return new_hist, new_hist, "Status: ✅ Healthy"
+
+    def _caps_cb(history):
+        md = (
+            "### Capabilities\n"
+            "- Chat (LLM text-generation, memory-aware prompt)\n"
+            "- Storefront Q&A (parking, attire, products, logistics)\n"
+            "- Adjustable: max_new_tokens, temperature, top-p"
+        )
+        new_hist = _append_bot_md(history, md)
+        return new_hist, new_hist
+
+    # Wire up (state + chatbot)
+    send.click(on_send, [history_state, msg, max_new, temp, topp], [history_state, chat, msg])
+    msg.submit(on_send, [history_state, msg, max_new, temp, topp], [history_state, chat, msg])
+
+    # Chips → prefill textbox
+    chip1.click(lambda: "What are the parking rules?", outputs=msg)
+    chip2.click(lambda: "Can I buy multiple parking passes?", outputs=msg)
+    chip3.click(lambda: "Is formal attire required?", outputs=msg)
+    chip4.click(lambda: "What time do the parking lots open?", outputs=msg)
+
+    # Health / Capabilities live inside Advanced
+    health_btn.click(_health_cb, inputs=[history_state], outputs=[history_state, chat, status_md])
+    caps_btn.click(_caps_cb,   inputs=[history_state], outputs=[history_state, chat])
+
+def clean_generation(text: str) -> str:
+    s = (text or "").strip()
+
+    # If the prompt contained "Assistant:", keep only what comes after the last one
+    last = s.rfind("Assistant:")
+    if last != -1:
+        s = s[last + len("Assistant:"):].strip()
+
+    # If it accidentally continued into a new "User:" or instructions, cut there
+    cut_marks = ["\nUser:", "\nYOU ARE ANSWERING", "\nProducts:", "\nVenue rules:", "\nParking rules:"]
+    cut_positions = [s.find(m) for m in cut_marks if s.find(m) != -1]
+    if cut_positions:
+        s = s[:min(cut_positions)].strip()
+
+    # Collapse repeated lines like "Yes, multiple parking passes..." spam
+    lines, out = s.splitlines(), []
+    seen = set()
+    for ln in lines:
+        # dedupe only exact consecutive repeats; keep normal conversation lines
+        if not out or ln != out[-1]:
+            out.append(ln)
+    return "\n".join(out).strip()
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")))

core/memory.py

@@ -0,0 +1,34 @@
+# core/memory.py
+
+META_MARKERS = ("### Status:", "### Capabilities", "Status:", "Capabilities", "Model:", "Storefront JSON:")
+
+def _is_meta(s: str | None) -> bool:
+    if not s: return False
+    ss = s.strip()
+    return any(m in ss for m in META_MARKERS)
+
+def build_prompt_from_history(history, user_text, k=4) -> str:
+    """
+    history: list[[user, bot], ...] from Gradio Chatbot.
+    Keep prompt compact; exclude meta/diagnostic messages.
+    """
+    lines = [
+        "System: Answer questions about the university graduation storefront.",
+        "System: Be concise. If unsure, state what is known."
+    ]
+
+    # Keep only the last k turns that aren't meta
+    kept = []
+    for u, b in (history or []):
+        if u and not _is_meta(u):
+            kept.append(("User", u))
+        if b and not _is_meta(b):
+            kept.append(("Assistant", b))
+    kept = kept[-(2*k):]  # up to k exchanges
+
+    for role, text in kept:
+        lines.append(f"{role}: {text}")
+
+    lines.append(f"User: {user_text}")
+    lines.append("Assistant:")
+    return "\n".join(lines)

core/model.py

@@ -0,0 +1,45 @@
+# core/model.py
+import re, os
+from transformers import pipeline, StoppingCriteria, StoppingCriteriaList
+
+MODEL_NAME = os.getenv("HF_MODEL_GENERATION", "distilgpt2")
+_pipe = None
+
+class StopOnMarkers(StoppingCriteria):
+    def __init__(self, tokenizer, stop_strs=("\nUser:", "\nSystem:", "\n###", "\nProducts:", "\nVenue rules:", "\nParking rules:")):
+        self.tokenizer = tokenizer
+        self.stop_ids = [tokenizer(s, add_special_tokens=False).input_ids for s in stop_strs]
+
+    def __call__(self, input_ids, scores, **kwargs):
+        # stop if any marker sequence just appeared at the end
+        for seq in self.stop_ids:
+            L = len(seq)
+            if L and len(input_ids[0]) >= L and input_ids[0][-L:].tolist() == seq:
+                return True
+        return False
+
+def _get_pipe():
+    global _pipe
+    if _pipe is None:
+        _pipe = pipeline("text-generation", model=MODEL_NAME)
+    return _pipe
+
+def model_generate(prompt, max_new_tokens=96, temperature=0.7, top_p=0.9):
+    pipe = _get_pipe()
+    tok = pipe.tokenizer
+
+    stop = StoppingCriteriaList([StopOnMarkers(tok)])
+
+    out = pipe(
+        prompt,
+        max_new_tokens=int(max_new_tokens),
+        do_sample=True,
+        temperature=float(temperature),
+        top_p=float(top_p),
+        repetition_penalty=1.15,          # discourages exact loops
+        no_repeat_ngram_size=3,           # blocks short repeats like "Account/Account"
+        pad_token_id=tok.eos_token_id or 50256,
+        eos_token_id=tok.eos_token_id,    # stop at EOS if model supports
+        stopping_criteria=stop,
+    )
+    return out[0]["generated_text"]

core/storefront.py

@@ -0,0 +1,175 @@
+# core/storefront.py
+import json, os
+
+def clean_generation(text: str) -> str:
+    s = (text or "").strip()
+
+    # Keep only text after the last "Assistant:"
+    last = s.rfind("Assistant:")
+    if last != -1:
+        s = s[last + len("Assistant:"):].strip()
+
+    # Cut at the first sign of a new turn or meta
+    cut_marks = ["\nUser:", "\nSystem:", "\n###", "\nProducts:", "\nVenue rules:", "\nParking rules:"]
+    cuts = [s.find(m) for m in cut_marks if s.find(m) != -1]
+    if cuts:
+        s = s[:min(cuts)].strip()
+
+    # Remove egregious token loops like "Account/Account/..."
+    s = re.sub(r"(?:\b([A-Z][a-zA-Z0-9_/.-]{2,})\b(?:\s*/\s*\1\b)+)", r"\1", s)
+
+    # Collapse consecutive duplicate lines
+    dedup = []
+    for ln in s.splitlines():
+        if not dedup or ln.strip() != dedup[-1].strip():
+            dedup.append(ln)
+    return "\n".join(dedup).strip()
+
+HELP_KEYWORDS = {
+    "help", "assist", "assistance", "tips", "how do i", "what can you do",
+    "graduation help", "help me with graduation", "can you help me with graduation"
+}
+
+STORE_KEYWORDS = {
+    "cap", "gown", "parking", "pass", "passes", "attire", "dress",
+    "venue", "logistics", "shipping", "pickup", "lot", "lots", "arrival", "size", "sizing"
+}
+
+def is_storefront_query(text: str) -> bool:
+    t = (text or "").lower()
+    return any(k in t for k in STORE_KEYWORDS) or any(k in t for k in HELP_KEYWORDS)
+
+def _get_lots_open_hours(data) -> int:
+    try:
+        return int(((data or {}).get("logistics") or {}).get("lots_open_hours_before") or 2)
+    except Exception:
+        return 2
+
+# Main router (drop-in)
+def storefront_qna(data, user_text: str) -> str | None:
+    """
+    Deterministic storefront answers first:
+      - single-word intents (parking / wear / passes)
+      - help/capability prompt
+      - FAQ (if you have answer_faq)
+      - explicit rules queries
+      - 'lots open' timing
+      - compact products list
+    Returns None to allow LLM fallback in your chat pipeline.
+    """
+    if not user_text:
+        return None
+    t = user_text.strip().lower()
+
+    # 1) Single-word / exact intents to avoid LLM hallucinations
+    if t in {"parking"}:
+        _, pr = get_rules(data)
+        if pr:
+            return "Parking rules:\n- " + "\n- ".join(pr)
+
+    # Map 'wear/attire' variants directly to venue rules
+    if t in {"venue", "attire", "dress", "dress code", "wear"} or "what should i wear" in t:
+        vr, _ = get_rules(data)
+        if vr:
+            return "Venue rules:\n- " + "\n- ".join(vr)
+
+    # Parking passes (multiple allowed)
+    if t in {"passes", "parking pass", "parking passes"}:
+        return "Yes, multiple parking passes are allowed per student."
+
+    # 2) Help / capability intent → deterministic guidance
+    if any(k in t for k in HELP_KEYWORDS):
+        return (
+            "I can help with the graduation storefront. Try:\n"
+            "- “What are the parking rules?”\n"
+            "- “Can I buy multiple parking passes?”\n"
+            "- “Is formal attire required?”\n"
+            "- “Where do I pick up the gown?”\n"
+            "- “When do lots open?”"
+        )
+
+    # 3) JSON-driven FAQ (if available)
+    try:
+        a = answer_faq(data, t)
+        if a:
+            return a
+    except Exception:
+        pass  # answer_faq may not exist or data may be None
+
+    # 4) Explicit rules phrasing (keeps answers tight and consistent)
+    if "parking" in t and "rule" in t:
+        _, pr = get_rules(data)
+        if pr:
+            return "Parking rules:\n- " + "\n- ".join(pr)
+
+    if ("venue" in t and "rule" in t) or "attire" in t or "dress code" in t:
+        vr, _ = get_rules(data)
+        if vr:
+            return "Venue rules:\n- " + "\n- ".join(vr)
+
+    # 5) “When do lots open?” / hours / time
+    if "parking" in t and ("hours" in t or "time" in t or "open" in t):
+        lots_open = _get_lots_open_hours(data)
+        return f"Parking lots open {lots_open} hours before the ceremony."
+
+    # 6) Product info (cap/gown/parking pass)
+    if any(k in t for k in ("cap", "gown", "parking pass", "product", "item", "price")):
+        prods = extract_products(data)
+        if prods:
+            lines = []
+            for p in prods:
+                name = p.get("name", "Item")
+                price = p.get("price", p.get("price_usd", ""))
+                notes = p.get("notes", p.get("description", ""))
+                price_str = f"${price:.2f}" if isinstance(price, (int, float)) else str(price)
+                lines.append(f"{name} — {price_str}: {notes}")
+            return "\n".join(lines)
+
+    # No deterministic match → let the caller fall back to the LLM
+    return None
+
+def _find_json():
+    candidates = [
+        os.path.join(os.getcwd(), "storefront_data.json"),
+        os.path.join(os.getcwd(), "agenticcore", "storefront_data.json"),
+    ]
+    for p in candidates:
+        if os.path.exists(p):
+            return p
+    return None
+
+def load_storefront():
+    p = _find_json()
+    if not p:
+        return None
+    with open(p, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+def _string_in_any(s, variants):
+    s = s.lower()
+    return any(v in s for v in variants)
+
+def answer_faq(data, text: str):
+    """Very small FAQ matcher by substring; safe if faq[] missing."""
+    faq = (data or {}).get("faq") or []
+    t = text.lower()
+    for item in faq:
+        qs = item.get("q") or []
+        if any(q.lower() in t for q in qs):
+            return item.get("a")
+    return None
+
+def extract_products(data):
+    prods = []
+    for p in (data or {}).get("products", []):
+        prods.append({
+            "sku": p.get("sku",""),
+            "name": p.get("name",""),
+            "price": p.get("price_usd",""),
+            "notes": (p.get("description") or "")[:140],
+        })
+    return prods
+
+def get_rules(data):
+    pol = (data or {}).get("policies", {}) or {}
+    return pol.get("venue_rules", []), pol.get("parking_rules", [])

space_app.py

@@ -1,41 +0,0 @@
-import os
-import gradio as gr
-from transformers import pipeline
-
-MODEL_NAME = os.getenv("HF_MODEL_GENERATION", "distilgpt2")
-
-_pipe = None
-def _get_pipe():
-    global _pipe
-    if _pipe is None:
-        _pipe = pipeline("text-generation", model=MODEL_NAME)
-    return _pipe
-
-def chat_fn(message, max_new_tokens=128, temperature=0.8, top_p=0.95):
-    message = (message or "").strip()
-    if not message:
-        return "Please type something!"
-    pipe = _get_pipe()
-    out = pipe(
-        message,
-        max_new_tokens=int(max_new_tokens),
-        do_sample=True,
-        temperature=float(temperature),
-        top_p=float(top_p),
-        pad_token_id=50256
-    )
-    return out[0]["generated_text"]
-
-with gr.Blocks(title="Agentic-Chat-bot") as demo:
-    gr.Markdown("# 🤖 Agentic Chat Bot\nGradio + Transformers demo")
-    prompt = gr.Textbox(label="Prompt", placeholder="Ask me anything…", lines=4)
-    out = gr.Textbox(label="Response", lines=6)
-    max_new = gr.Slider(32, 512, 128, 1, label="Max new tokens")
-    temp = gr.Slider(0.1, 1.5, 0.8, 0.05, label="Temperature")
-    topp = gr.Slider(0.1, 1.0, 0.95, 0.05, label="Top-p")
-    btn = gr.Button("Send")
-    btn.click(chat_fn, [prompt, max_new, temp, topp], out)
-    prompt.submit(chat_fn, [prompt, max_new, temp, topp], out)
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")))

storefront_data.json

@@ -0,0 +1,84 @@
+{
+  "products": [
+    {
+      "sku": "CG-SET",
+      "name": "Cap & Gown Set",
+      "price_usd": 59.0,
+      "description": "Tassel included; ships until 10 days before the event. Sizes available at pickup; exchange allowed on-site if inventory permits."
+    },
+    {
+      "sku": "PK-1",
+      "name": "Parking Pass",
+      "price_usd": 10.0,
+      "description": "One vehicle per pass. Multiple passes are allowed per student for extended family or guests."
+    }
+  ],
+  "policies": {
+    "parking_rules": [
+      "No double parking.",
+      "Vehicles parked in handicap spaces will be towed."
+    ],
+    "venue_rules": [
+      "Formal attire is recommended (not required).",
+      "No muscle shirts.",
+      "No sagging pants."
+    ]
+  },
+  "logistics": {
+    "shipping_cutoff_days": 10,
+    "shipping_window_business_days": "3–5",
+    "pickup_location": "Student Center Bookstore",
+    "arrival_times": {
+      "graduates_minutes_early": 90,
+      "guests_minutes_early": 60
+    },
+    "lots_open_hours_before": 2,
+    "lots": ["A", "B"],
+    "overflow": "As needed"
+  },
+  "faq": [
+    {
+      "q": [
+        "Can I buy multiple parking passes?",
+        "multiple passes",
+        "more than one parking pass",
+        "extra parking pass"
+      ],
+      "a": "Yes, multiple parking passes are allowed per student."
+    },
+    {
+      "q": [
+        "What time do the parking lots open?",
+        "When do lots open",
+        "parking hours",
+        "what time parking"
+      ],
+      "a": "Parking lots open 2 hours before the ceremony."
+    },
+    {
+      "q": [
+        "Is formal attire required?",
+        "dress code",
+        "what should I wear",
+        "attire rules"
+      ],
+      "a": "Formal attire is recommended but not required. No muscle shirts or sagging pants."
+    },
+    {
+      "q": [
+        "Where do I pick up the gown?",
+        "gown pickup",
+        "pickup location"
+      ],
+      "a": "Pickup is at the Student Center Bookstore during the week prior to the event."
+    },
+    {
+      "q": [
+        "Shipping cutoff",
+        "last day to ship",
+        "when is shipping available until"
+      ],
+      "a": "Shipping is available until 10 days before the event. Typical shipping takes 3–5 business days."
+    }
+  ]
+}