Remove Firebase/Firestore from backend — use local JSON persistence only

Deletes firebase_client.py and strips all Tier-1 Firestore code paths from
history.py, trends.py, and scoring/engine.py. Persistence now falls through
directly to the local JSON file (data/history.json) with in-memory fallback.
Eliminates the repeated "firebase-admin not installed" warnings in HF logs.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

api/routes/history.py

@@ -3,9 +3,8 @@ PhilVerify — History Route
 GET /history — Returns past verification logs with pagination.
 
 Persistence tier order (best to worst):
-  1. Firestore — requires Cloud Firestore API to be enabled in GCP console
-  2. Local JSON file — data/history.json, survives server restarts, no setup needed
-  3. In-memory list — last resort, resets on every restart
+  1. Local JSON file — data/history.json, survives server restarts
+  2. In-memory list — last resort, resets on every restart
 """
 import json
 import logging
@@ -70,18 +69,7 @@ def record_verification(entry: dict) -> None:
 async def get_history_entry(entry_id: str) -> dict:
     logger.info("GET /history/%s", entry_id)
 
-    # Tier 1: Firestore
-    try:
-        from firebase_client import get_firestore
-        db = get_firestore()
-        if db:
-            doc = db.collection("verifications").document(entry_id).get()
-            if doc.exists:
-                return doc.to_dict()
-    except Exception as e:
-        logger.debug("Firestore detail unavailable (%s) — trying local file", e)
-
-    # Tier 2: Local JSON file
+    # Tier 1: Local JSON file
     try:
         records = _load_history_file()
         for r in records:
@@ -102,7 +90,7 @@ async def get_history_entry(entry_id: str) -> dict:
     "",
     response_model=HistoryResponse,
     summary="Get verification history",
-    description="Returns past verifications ordered by most recent. Reads from Firestore when configured, falls back to in-memory store.",
+    description="Returns past verifications ordered by most recent. Reads from local JSON file, falls back to in-memory store.",
 )
 async def get_history(
     page: int = Query(1, ge=1, description="Page number"),
@@ -111,33 +99,7 @@ async def get_history(
 ) -> HistoryResponse:
     logger.info("GET /history | page=%d limit=%d", page, limit)
 
-    # ── Tier 1: Firestore ─────────────────────────────────────────────────────
-    try:
-        from firebase_client import get_verifications, get_verification_count
-        vf = verdict_filter.value if verdict_filter else None
-        offset = (page - 1) * limit
-        entries_raw = await get_verifications(limit=limit, offset=offset, verdict_filter=vf)
-        total = await get_verification_count(verdict_filter=vf)
-        if entries_raw or total > 0:
-            return HistoryResponse(
-                total=total,
-                entries=[
-                    HistoryEntry(
-                        id=e["id"],
-                        timestamp=e["timestamp"],
-                        input_type=e.get("input_type", "text"),
-                        text_preview=e.get("text_preview", "")[:120],
-                        verdict=Verdict(e["verdict"]),
-                        confidence=e["confidence"],
-                        final_score=e["final_score"],
-                    )
-                    for e in entries_raw
-                ],
-            )
-    except Exception as e:
-        logger.debug("Firestore history unavailable (%s) — trying local file", e)
-
-    # ── Tier 2: Local JSON file ───────────────────────────────────────────────
+    # ── Tier 1: Local JSON file ───────────────────────────────────────────────
     # Load from file rather than in-memory list so data survives restarts.
     file_entries = list(reversed(_load_history_file()))
     if file_entries:

api/routes/trends.py

@@ -14,18 +14,9 @@ router = APIRouter(prefix="/trends", tags=["Trends"])
 def _load_all_history() -> list[dict]:
     """
     Return all history records from the best available source:
-      1. Firestore  2. Local JSON file  3. In-memory list (fallback)
+      1. Local JSON file  2. In-memory list (fallback)
     """
-    # Tier 1: Firestore
-    try:
-        from firebase_client import get_all_verifications_sync
-        records = get_all_verifications_sync()
-        if records:
-            return records
-    except Exception:
-        pass
-
-    # Tier 2: Local JSON file (persists across restarts)
+    # Tier 1: Local JSON file (persists across restarts)
     try:
         from api.routes.history import _load_history_file
         records = _load_history_file()

firebase_client.py

@@ -1,143 +0,0 @@
-"""
-PhilVerify — Firebase / Firestore Client
-Initializes firebase-admin SDK and provides typed helpers for persistence.
-
-Setup:
-  1. Go to Firebase Console → Project Settings → Service Accounts
-  2. Click "Generate new private key" → save as `serviceAccountKey.json`
-     in the PhilVerify project root (already in .gitignore)
-  3. Set FIREBASE_PROJECT_ID in .env
-
-Collections:
-  verifications/   — one doc per verification run
-  trends/summary   — aggregated entity/topic counters
-"""
-import logging
-import os
-from functools import lru_cache
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-_SERVICEACCOUNT_PATH = Path(__file__).parent / "serviceAccountKey.json"
-_db = None  # Firestore client singleton
-
-
-def get_firestore():
-    """Return the Firestore client, or None if Firebase is not configured."""
-    global _db
-    if _db is not None:
-        return _db
-
-    try:
-        import firebase_admin
-        from firebase_admin import credentials, firestore
-
-        if firebase_admin._DEFAULT_APP_NAME in firebase_admin._apps:
-            _db = firestore.client()
-            return _db
-
-        if _SERVICEACCOUNT_PATH.exists():
-            # Service account key file available (local dev + CI)
-            cred = credentials.Certificate(str(_SERVICEACCOUNT_PATH))
-            firebase_admin.initialize_app(cred)
-            logger.info("Firebase initialized via service account key")
-        elif os.getenv("GOOGLE_APPLICATION_CREDENTIALS") or os.getenv("K_SERVICE"):
-            # Cloud Run (K_SERVICE is always set) or explicit ADC path
-            cred = credentials.ApplicationDefault()
-            firebase_admin.initialize_app(cred)
-            logger.info("Firebase initialized via Application Default Credentials")
-        else:
-            logger.warning(
-                "Firebase not configured — no serviceAccountKey.json and no "
-                "GOOGLE_APPLICATION_CREDENTIALS env var. History will use in-memory store."
-            )
-            return None
-
-        _db = firestore.client()
-        return _db
-
-    except ImportError:
-        logger.warning("firebase-admin not installed — Firestore disabled")
-        return None
-    except Exception as e:
-        logger.error("Firebase init error: %s — falling back to in-memory store", e)
-        return None
-
-
-async def save_verification(data: dict) -> bool:
-    """
-    Persist a verification result to Firestore.
-    Returns True on success, False if Firebase is unavailable.
-    """
-    db = get_firestore()
-    if db is None:
-        return False
-    try:
-        db.collection("verifications").document(data["id"]).set(data)
-        logger.debug("Verification %s saved to Firestore", data["id"])
-        return True
-    except Exception as e:
-        logger.error("Firestore write error: %s", e)
-        return False
-
-
-async def get_verifications(
-    limit: int = 20,
-    offset: int = 0,
-    verdict_filter: str | None = None,
-) -> list[dict]:
-    """Fetch verification history from Firestore ordered by timestamp desc."""
-    db = get_firestore()
-    if db is None:
-        return []
-    try:
-        from google.cloud.firestore_v1.base_query import FieldFilter
-        query = (
-            db.collection("verifications")
-            .order_by("timestamp", direction="DESCENDING")
-        )
-        if verdict_filter:
-            query = query.where(filter=FieldFilter("verdict", "==", verdict_filter))
-        docs = query.limit(limit + offset).stream()
-        results = [doc.to_dict() for doc in docs]
-        return results[offset : offset + limit]
-    except Exception as e:
-        logger.error("Firestore read error: %s", e)
-        return []
-
-
-def get_all_verifications_sync() -> list[dict]:
-    """Synchronously fetch ALL verification records from Firestore (used by trends aggregation)."""
-    db = get_firestore()
-    if db is None:
-        return []
-    try:
-        docs = (
-            db.collection("verifications")
-            .order_by("timestamp", direction="DESCENDING")
-            .limit(10_000)  # hard cap — more than enough for trends analysis
-            .stream()
-        )
-        return [doc.to_dict() for doc in docs]
-    except Exception as e:
-        logger.error("Firestore get_all_verifications_sync error: %s", e)
-        return []
-
-
-async def get_verification_count(verdict_filter: str | None = None) -> int:
-    """Return total count of verifications (with optional verdict filter)."""
-    db = get_firestore()
-    if db is None:
-        return 0
-    try:
-        from google.cloud.firestore_v1.base_query import FieldFilter
-        query = db.collection("verifications")
-        if verdict_filter:
-            query = query.where(filter=FieldFilter("verdict", "==", verdict_filter))
-        # Use aggregation query (Firestore native count)
-        result = query.count().get()
-        return result[0][0].value
-    except Exception as e:
-        logger.error("Firestore count error: %s", e)
-        return 0

scoring/engine.py

@@ -323,18 +323,9 @@ async def run_verification(
         "language": language.value,
     }
     try:
-        from firebase_client import save_verification
-        saved = await save_verification(history_entry)
-        if not saved:
-            # Firestore unavailable — fall back to in-memory store
-            from api.routes.history import record_verification
-            record_verification(history_entry)
+        from api.routes.history import record_verification
+        record_verification(history_entry)
     except Exception as e:
         logger.warning("Failed to record history: %s", e)
-        try:
-            from api.routes.history import record_verification
-            record_verification(history_entry)
-        except Exception:
-            pass
 
     return result