Spaces:
Sleeping
Sleeping
| """ | |
| memory_cloud.py — conversation long-term memory for Jarvis. | |
| Backend: Firebase Firestore (cloud only). No local fallback — if Firestore | |
| is unavailable, remember() reports failure and recall() returns nothing. | |
| """ | |
| import os | |
| import time | |
| _firestore = None | |
| _firestore_failed = False | |
| def _credentials_path(): | |
| p = os.environ.get("FIREBASE_CREDENTIALS_PATH", "").strip() | |
| if p: | |
| return p | |
| here = os.path.dirname(os.path.abspath(__file__)) | |
| return os.path.join(here, "firebase_service_account.json") | |
| def _init_firestore(): | |
| """Lazily init Firestore once. Returns client or None.""" | |
| global _firestore, _firestore_failed | |
| if _firestore is not None: | |
| return _firestore | |
| if _firestore_failed: | |
| return None | |
| try: | |
| import firebase_admin | |
| from firebase_admin import credentials, firestore | |
| import json as _json | |
| js = (os.environ.get("FIREBASE_CREDENTIALS_JSON") or "").strip() | |
| if js: | |
| info = _json.loads(js) | |
| app = firebase_admin.get_app() if firebase_admin._apps else firebase_admin.initialize_app( | |
| credentials.Certificate(info) | |
| ) | |
| else: | |
| path = _credentials_path() | |
| if not os.path.exists(path): | |
| print("[warn] No firebase_service_account.json - memory disabled (no local fallback).") | |
| _firestore_failed = True | |
| return None | |
| app = firebase_admin.get_app() if firebase_admin._apps else firebase_admin.initialize_app( | |
| credentials.Certificate(path) | |
| ) | |
| _firestore = firestore.client(app) | |
| print("[ok] Firebase Firestore connected for memory.") | |
| return _firestore | |
| except Exception as exc: | |
| print(f"[warn] Firestore unavailable ({exc}) - memory disabled.") | |
| _firestore_failed = True | |
| return None | |
| def remember(content: str) -> bool: | |
| """Save a fact/interaction to Firestore. False if Firestore unavailable.""" | |
| if not content: | |
| return False | |
| db = _init_firestore() | |
| if db is None: | |
| return False | |
| try: | |
| db.collection("jarvis_memory").add({"content": content, "ts": time.time()}) | |
| return True | |
| except Exception as exc: | |
| print(f"[warn] Firestore write failed ({exc}).") | |
| return False | |
| CHAT_DOC = "shared" | |
| CHAT_CAP = 12 | |
| def set_pref(key: str, value: str) -> bool: | |
| """Cross-channel preference (one doc, never raises).""" | |
| try: | |
| db = _init_firestore() | |
| if db is None: | |
| return False | |
| import time as _t | |
| ref = db.collection("jarvis_prefs").document("user") | |
| doc = ref.get() | |
| prefs = ((doc.to_dict() or {}).get("prefs") or {}) if doc.exists else {} | |
| prefs[key] = (value or "")[:300] | |
| ref.set({"prefs": prefs, "updated": _t.time()}) | |
| return True | |
| except Exception as exc: | |
| print(f"[warn] pref save failed ({exc}).") | |
| return False | |
| def get_prefs() -> dict: | |
| try: | |
| db = _init_firestore() | |
| if db is None: | |
| return {} | |
| doc = db.collection("jarvis_prefs").document("user").get() | |
| if doc.exists: | |
| return (doc.to_dict() or {}).get("prefs") or {} | |
| except Exception as exc: | |
| print(f"[warn] pref load failed ({exc}).") | |
| return {} | |
| def chat_load(limit: int = 8) -> list: | |
| """Shared BAT<->Telegram conversation (list of {r,t,ts,src}). Never raises.""" | |
| try: | |
| db = _init_firestore() | |
| if db is None: | |
| return [] | |
| doc = db.collection("jarvis_chat").document(CHAT_DOC).get() | |
| if doc.exists: | |
| msgs = (doc.to_dict() or {}).get("msgs") or [] | |
| msgs = sorted(msgs, key=lambda m: m.get("ts", 0)) | |
| return msgs[-limit:] | |
| except Exception as exc: | |
| print(f"[warn] chat load failed ({exc}).") | |
| return [] | |
| def chat_save(role: str, text: str, src: str = "?") -> bool: | |
| """Append one exchange line to the shared conversation. Never raises.""" | |
| try: | |
| db = _init_firestore() | |
| if db is None or not text: | |
| return False | |
| ref = db.collection("jarvis_chat").document(CHAT_DOC) | |
| doc = ref.get() | |
| msgs = ((doc.to_dict() or {}).get("msgs") or []) if doc.exists else [] | |
| msgs.append({"r": role, "t": text[:500], "ts": time.time(), "src": src}) | |
| msgs = sorted(msgs, key=lambda m: m.get("ts", 0))[-CHAT_CAP:] | |
| ref.set({"msgs": msgs, "updated": time.time()}) | |
| return True | |
| except Exception as exc: | |
| print(f"[warn] chat save failed ({exc}).") | |
| return False | |
| def stats() -> dict: | |
| """Count memory entries: history (jarvis_memory docs), contacts, chat turns. | |
| Never raises — returns zeros when offline.""" | |
| out = {"history": 0, "contacts": 0, "turns": 0} | |
| try: | |
| db = _init_firestore() | |
| if db is None: | |
| return out | |
| try: | |
| out["history"] = len(db.collection("jarvis_memory").get()) | |
| except Exception: | |
| pass | |
| try: | |
| out["contacts"] = len(db.collection("jarvis_contacts").get()) | |
| except Exception: | |
| pass | |
| try: | |
| doc = db.collection("jarvis_chat").document(CHAT_DOC).get() | |
| if doc.exists: | |
| out["turns"] = len((doc.to_dict() or {}).get("msgs") or []) | |
| except Exception: | |
| pass | |
| except Exception: | |
| pass | |
| return out | |
| def recall(limit: int = 10) -> str: | |
| """Return the most recent remembered items as a spoken-friendly string.""" | |
| db = _init_firestore() | |
| if db is None: | |
| return "" | |
| try: | |
| snaps = ( | |
| db.collection("jarvis_memory") | |
| .order_by("ts", direction="DESCENDING") | |
| .limit(limit) | |
| .get() | |
| ) | |
| parts = [s.to_dict().get("content", "") for s in snaps] | |
| return "; ".join(p for p in parts if p) | |
| except Exception as exc: | |
| print(f"[warn] Firestore read failed ({exc}).") | |
| return "" |