Update api/server.py

api/server.py

@@ -1,10 +1,12 @@
 # api/server.py
 import os
 import time
-from typing import Dict, List, Optional, Tuple
-from fastapi import FastAPI, UploadFile, File, Form
-from fastapi.responses import FileResponse
+from typing import Dict
+
+from fastapi import FastAPI, UploadFile, File, Form, Request
+from fastapi.responses import FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 
 from api.config import DEFAULT_COURSE_TOPICS, DEFAULT_MODEL
@@ -20,52 +22,100 @@ from api.clare_core import (
     summarize_conversation,
 )
 
-MODULE10_PATH = os.path.join(os.path.dirname(__file__), "module10_responsible_ai.pdf")
+# ----------------------------
+# Paths / Constants
+# ----------------------------
+API_DIR = os.path.dirname(__file__)
+REPO_ROOT = os.path.abspath(os.path.join(API_DIR, ".."))
+
+MODULE10_PATH = os.path.join(API_DIR, "module10_responsible_ai.pdf")
 MODULE10_DOC_TYPE = "Literature Review / Paper"
 
+WEB_DIST = os.path.join(REPO_ROOT, "web", "dist")
+WEB_INDEX = os.path.join(WEB_DIST, "index.html")
+WEB_ASSETS = os.path.join(WEB_DIST, "assets")
+
+# ----------------------------
+# App
+# ----------------------------
 app = FastAPI(title="Clare API")
 
-# ---- serve web build ----
-WEB_DIST = os.path.join(os.path.dirname(__file__), "..", "web", "dist")
-app.mount("/assets", StaticFiles(directory=os.path.join(WEB_DIST, "assets")), name="assets")
+# If later you split FE/BE domain, this prevents CORS headaches.
+# For same-origin (Docker Space) it doesn't hurt.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ----------------------------
+# Static hosting (Vite build)
+# ----------------------------
+# Vite build typically outputs: web/dist/index.html + web/dist/assets/*
+# We mount /assets so <script src="/assets/..."> works.
+if os.path.isdir(WEB_ASSETS):
+    app.mount("/assets", StaticFiles(directory=WEB_ASSETS), name="assets")
+
+# Optionally also serve other static files in dist root (favicon, etc.)
+if os.path.isdir(WEB_DIST):
+    app.mount("/static", StaticFiles(directory=WEB_DIST), name="static")
+
 
 @app.get("/")
 def index():
-    return FileResponse(os.path.join(WEB_DIST, "index.html"))
+    if os.path.exists(WEB_INDEX):
+        return FileResponse(WEB_INDEX)
+    return JSONResponse(
+        {"detail": "web/dist not found. Build frontend first (web/dist/index.html)."},
+        status_code=500,
+    )
+
 
-# ---- in-memory session store (MVP) ----
-# 生产环境建议 Redis / DB；但你第一阶段完全够用
+# ----------------------------
+# In-memory session store (MVP)
+# ----------------------------
+# Production -> Redis / DB
 SESSIONS: Dict[str, Dict] = {}
 
+
+def _preload_module10_chunks():
+    if os.path.exists(MODULE10_PATH):
+        try:
+            return build_rag_chunks_from_file(MODULE10_PATH, MODULE10_DOC_TYPE) or []
+        except Exception as e:
+            print(f"[preload] module10 parse failed: {repr(e)}")
+            return []
+    return []
+
+
+MODULE10_CHUNKS_CACHE = _preload_module10_chunks()
+
+
 def _get_session(user_id: str) -> Dict:
     if user_id not in SESSIONS:
-        # preload module10
-        course_outline = DEFAULT_COURSE_TOPICS
-        rag_chunks = []
-        if os.path.exists(MODULE10_PATH):
-            rag_chunks = build_rag_chunks_from_file(MODULE10_PATH, MODULE10_DOC_TYPE)
-
         SESSIONS[user_id] = {
             "user_id": user_id,
             "name": "",
             "history": [],
             "weaknesses": [],
             "cognitive_state": {"confusion": 0, "mastery": 0},
-            "course_outline": course_outline,
-            "rag_chunks": rag_chunks,
+            "course_outline": DEFAULT_COURSE_TOPICS,
+            # preload base reading
+            "rag_chunks": list(MODULE10_CHUNKS_CACHE),
             "model_name": DEFAULT_MODEL,
         }
     return SESSIONS[user_id]
 
+
+# ----------------------------
+# Schemas
+# ----------------------------
 class LoginReq(BaseModel):
     name: str
     user_id: str
 
-@app.post("/api/login")
-def login(req: LoginReq):
-    sess = _get_session(req.user_id)
-    sess["name"] = req.name
-    return {"ok": True, "user": {"name": req.name, "user_id": req.user_id}}
 
 class ChatReq(BaseModel):
     user_id: str
@@ -74,37 +124,80 @@ class ChatReq(BaseModel):
     language_preference: str = "Auto"
     doc_type: str = "Syllabus"
 
+
+class ExportReq(BaseModel):
+    user_id: str
+    learning_mode: str
+
+
+class SummaryReq(BaseModel):
+    user_id: str
+    learning_mode: str
+    language_preference: str = "Auto"
+
+
+# ----------------------------
+# API Routes
+# ----------------------------
+@app.post("/api/login")
+def login(req: LoginReq):
+    user_id = (req.user_id or "").strip()
+    name = (req.name or "").strip()
+    if not user_id or not name:
+        return JSONResponse({"ok": False, "error": "Missing name/user_id"}, status_code=400)
+
+    sess = _get_session(user_id)
+    sess["name"] = name
+    return {"ok": True, "user": {"name": name, "user_id": user_id}}
+
+
 @app.post("/api/chat")
 def chat(req: ChatReq):
-    sess = _get_session(req.user_id)
-
+    user_id = (req.user_id or "").strip()
     msg = (req.message or "").strip()
+
+    if not user_id:
+        return JSONResponse({"error": "Missing user_id"}, status_code=400)
+
+    sess = _get_session(user_id)
+
     if not msg:
-        return {"reply": "", "session_status_md": render_session_status(req.learning_mode, sess["weaknesses"], sess["cognitive_state"]), "refs": []}
+        return {
+            "reply": "",
+            "session_status_md": render_session_status(
+                req.learning_mode, sess["weaknesses"], sess["cognitive_state"]
+            ),
+            "refs": [],
+            "latency_ms": 0.0,
+        }
 
     resolved_lang = detect_language(msg, req.language_preference)
 
     sess["weaknesses"] = update_weaknesses_from_message(msg, sess["weaknesses"])
     sess["cognitive_state"] = update_cognitive_state_from_message(msg, sess["cognitive_state"])
 
-    # academic gating：沿用你 app.py 的 is_academic_query 逻辑（建议后续挪进 api utils）
+    # RAG
     rag_context_text, rag_used_chunks = retrieve_relevant_chunks(msg, sess["rag_chunks"])
 
     start_ts = time.time()
-    answer, new_history = chat_with_clare(
-        message=msg,
-        history=sess["history"],
-        model_name=sess["model_name"],
-        language_preference=resolved_lang,
-        learning_mode=req.learning_mode,
-        doc_type=req.doc_type,
-        course_outline=sess["course_outline"],
-        weaknesses=sess["weaknesses"],
-        cognitive_state=sess["cognitive_state"],
-        rag_context=rag_context_text,
-    )
-    latency_ms = (time.time() - start_ts) * 1000.0
+    try:
+        answer, new_history = chat_with_clare(
+            message=msg,
+            history=sess["history"],
+            model_name=sess["model_name"],
+            language_preference=resolved_lang,
+            learning_mode=req.learning_mode,
+            doc_type=req.doc_type,
+            course_outline=sess["course_outline"],
+            weaknesses=sess["weaknesses"],
+            cognitive_state=sess["cognitive_state"],
+            rag_context=rag_context_text,
+        )
+    except Exception as e:
+        print(f"[chat] error: {repr(e)}")
+        return JSONResponse({"error": f"chat failed: {repr(e)}"}, status_code=500)
 
+    latency_ms = (time.time() - start_ts) * 1000.0
     sess["history"] = new_history
 
     refs = [
@@ -114,46 +207,67 @@ def chat(req: ChatReq):
 
     return {
         "reply": answer,
-        "session_status_md": render_session_status(req.learning_mode, sess["weaknesses"], sess["cognitive_state"]),
+        "session_status_md": render_session_status(
+            req.learning_mode, sess["weaknesses"], sess["cognitive_state"]
+        ),
         "refs": refs,
         "latency_ms": latency_ms,
     }
 
+
 @app.post("/api/upload")
 async def upload(
     user_id: str = Form(...),
     doc_type: str = Form(...),
     file: UploadFile = File(...),
 ):
+    user_id = (user_id or "").strip()
+    doc_type = (doc_type or "").strip()
+
+    if not user_id:
+        return JSONResponse({"ok": False, "error": "Missing user_id"}, status_code=400)
+    if not file or not file.filename:
+        return JSONResponse({"ok": False, "error": "Missing file"}, status_code=400)
+
     sess = _get_session(user_id)
 
-    # 保存到临时文件
+    # Save to /tmp
     tmp_path = f"/tmp/{file.filename}"
     content = await file.read()
     with open(tmp_path, "wb") as f:
         f.write(content)
 
-    # 更新 topics（仅 syllabus）
+    # Update topics only for syllabus
     if doc_type == "Syllabus":
-        # 复用你 syllabus_utils 的逻辑：它期待 gradio file_obj，有 .name
-        class _F: pass
-        fo = _F(); fo.name = tmp_path
-        sess["course_outline"] = extract_course_topics_from_file(fo, doc_type)
+        class _F:
+            pass
 
-    # 更新 rag chunks（所有文件都可）
-    new_chunks = build_rag_chunks_from_file(tmp_path, doc_type)
-    sess["rag_chunks"] = (sess["rag_chunks"] or []) + (new_chunks or [])
+        fo = _F()
+        fo.name = tmp_path
+        try:
+            sess["course_outline"] = extract_course_topics_from_file(fo, doc_type)
+        except Exception as e:
+            print(f"[upload] syllabus parse error: {repr(e)}")
 
-    status_md = f"✅ Loaded Module 10 base reading + uploaded {doc_type} file."
+    # Update rag chunks for any doc
+    try:
+        new_chunks = build_rag_chunks_from_file(tmp_path, doc_type) or []
+        sess["rag_chunks"] = (sess["rag_chunks"] or []) + new_chunks
+    except Exception as e:
+        print(f"[upload] rag build error: {repr(e)}")
+        new_chunks = []
+
+    status_md = f"✅ Loaded base reading + uploaded {doc_type} file."
     return {"ok": True, "added_chunks": len(new_chunks), "status_md": status_md}
 
-class ExportReq(BaseModel):
-    user_id: str
-    learning_mode: str
 
 @app.post("/api/export")
 def api_export(req: ExportReq):
-    sess = _get_session(req.user_id)
+    user_id = (req.user_id or "").strip()
+    if not user_id:
+        return JSONResponse({"error": "Missing user_id"}, status_code=400)
+
+    sess = _get_session(user_id)
     md = export_conversation(
         sess["history"],
         sess["course_outline"],
@@ -163,14 +277,14 @@ def api_export(req: ExportReq):
     )
     return {"markdown": md}
 
-class SummaryReq(BaseModel):
-    user_id: str
-    learning_mode: str
-    language_preference: str = "Auto"
 
 @app.post("/api/summary")
 def api_summary(req: SummaryReq):
-    sess = _get_session(req.user_id)
+    user_id = (req.user_id or "").strip()
+    if not user_id:
+        return JSONResponse({"error": "Missing user_id"}, status_code=400)
+
+    sess = _get_session(user_id)
     md = summarize_conversation(
         sess["history"],
         sess["course_outline"],
@@ -181,8 +295,28 @@ def api_summary(req: SummaryReq):
     )
     return {"markdown": md}
 
+
 @app.get("/api/memoryline")
 def memoryline(user_id: str):
-    # v1 写死也可以；前端只渲染
-    _ = _get_session(user_id)
+    _ = _get_session((user_id or "").strip())
+    # v1: 写死也没问题；前端只渲染
     return {"next_review_label": "T+7", "progress_pct": 0.4}
+
+
+# ----------------------------
+# SPA Fallback (important!)
+# ----------------------------
+# If user refreshes /some/route, FE router needs index.html.
+@app.get("/{full_path:path}")
+def spa_fallback(full_path: str, request: Request):
+    # Do not hijack API/static paths
+    if full_path.startswith("api/") or full_path.startswith("assets/") or full_path.startswith("static/"):
+        return JSONResponse({"detail": "Not Found"}, status_code=404)
+
+    if os.path.exists(WEB_INDEX):
+        return FileResponse(WEB_INDEX)
+
+    return JSONResponse(
+        {"detail": "web/dist not found. Build frontend first."},
+        status_code=500,
+    )