Update main.py

main.py

@@ -1,472 +1,472 @@
-from __future__ import annotations
-
-import json
-import os
-import uuid
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Optional
-
-import numpy as np
-from fastapi import FastAPI, Request
-from fastapi.responses import HTMLResponse, JSONResponse
-from fastapi.staticfiles import StaticFiles
-from fastapi.templating import Jinja2Templates
-
-# Optional but recommended for similarity search.
-# If sentence-transformers is unavailable, the app still works with a fallback.
-try:
-    from sentence_transformers import SentenceTransformer
-except Exception:  # pragma: no cover
-    SentenceTransformer = None  # type: ignore
-
-try:
-    from sklearn.metrics.pairwise import cosine_similarity
-except Exception:  # pragma: no cover
-    cosine_similarity = None  # type: ignore
-
-
-APP_TITLE = "Human Intelligence"
-DATA_DIR = Path(os.environ.get("DATA_DIR", "/app/data"))
-THREADS_DIR = DATA_DIR / "threads"
-INDEX_FILE = DATA_DIR / "index.json"
-EMBED_FILE = DATA_DIR / "embeddings.json"
-TEMPLATES_DIR = Path("/app/templates")
-SIMILARITY_THRESHOLD = float(os.environ.get("SIMILARITY_THRESHOLD", "0.82"))
-
-DATA_DIR.mkdir(parents=True, exist_ok=True)
-THREADS_DIR.mkdir(parents=True, exist_ok=True)
-TEMPLATES_DIR.mkdir(parents=True, exist_ok=True)
-
-app = FastAPI(title=APP_TITLE)
-templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
-
-# Serve any public assets you may add later.
-app.mount("/data", StaticFiles(directory=str(DATA_DIR)), name="data")
-
-_embed_model = None
-
-
-# ---------------------------------------------------------------------
-# Utilities
-# ---------------------------------------------------------------------
-def now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def read_json(path: Path, default: Any):
-    if not path.exists():
-        return default
-    try:
-        return json.loads(path.read_text(encoding="utf-8"))
-    except Exception:
-        return default
-
-
-def write_json(path: Path, data: Any) -> None:
-    tmp = path.with_suffix(path.suffix + ".tmp")
-    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2, default=str), encoding="utf-8")
-    tmp.replace(path)
-
-
-def get_username(request: Request, payload: dict | None = None) -> str:
-    """
-    Priority:
-      1) X-User header
-      2) JSON payload username
-      3) guest
-    This keeps the app simple and deployment-friendly.
-    """
-    header_name = request.headers.get("x-user", "").strip()
-    if header_name:
-        return header_name
-
-    if payload:
-        p_name = str(payload.get("username", "")).strip()
-        if p_name:
-            return p_name
-
-    return "Guest"
-
-
-# ---------------------------------------------------------------------
-# Embeddings / similarity
-# ---------------------------------------------------------------------
-def load_embed_model():
-    global _embed_model
-    if _embed_model is None:
-        if SentenceTransformer is None:
-            return None
-        _embed_model = SentenceTransformer("all-MiniLM-L6-v2")
-    return _embed_model
-
-
-def embed_text(text: str) -> list[float]:
-    model = load_embed_model()
-    if model is None:
-        return []
-
-    vec = model.encode(text, normalize_embeddings=True)
-    return vec.tolist()
-
-
-def load_embed_index() -> dict:
-    return read_json(EMBED_FILE, {})
-
-
-def save_embed_index(idx: dict) -> None:
-    write_json(EMBED_FILE, idx)
-
-
-def find_similar_thread(question: str) -> Optional[tuple[str, float]]:
-    idx = load_embed_index()
-    if not idx:
-        return None
-
-    if cosine_similarity is None:
-        return None
-
-    q_vec = embed_text(question)
-    if not q_vec:
-        return None
-
-    ids = list(idx.keys())
-    vecs = np.array([idx[tid]["vector"] for tid in ids], dtype=float)
-
-    if vecs.size == 0:
-        return None
-
-    sims = cosine_similarity(np.array(q_vec, dtype=float).reshape(1, -1), vecs)[0]
-    best_i = int(np.argmax(sims))
-    score = float(sims[best_i])
-
-    if score >= SIMILARITY_THRESHOLD:
-        return ids[best_i], score
-    return None
-
-
-# ---------------------------------------------------------------------
-# Storage
-# ---------------------------------------------------------------------
-def load_index() -> list[dict]:
-    return read_json(INDEX_FILE, [])
-
-
-def save_index(idx: list[dict]) -> None:
-    write_json(INDEX_FILE, idx)
-
-
-def thread_path(tid: str) -> Path:
-    return THREADS_DIR / f"{tid}.json"
-
-
-def load_thread(tid: str) -> Optional[dict]:
-    return read_json(thread_path(tid), None)
-
-
-def save_thread(thread: dict) -> None:
-    write_json(thread_path(thread["id"]), thread)
-
-
-def ensure_thread_schema(thread: dict) -> dict:
-    thread.setdefault("id", uuid.uuid4().hex)
-    thread.setdefault("question", "")
-    thread.setdefault("author", "Guest")
-    thread.setdefault("created_at", now_iso())
-    thread.setdefault("messages", [])
-    return thread
-
-
-# ---------------------------------------------------------------------
-# Content safety
-# ---------------------------------------------------------------------
-_toxic_pipe = None
-
-def load_safety_pipe():
-    global _toxic_pipe
-    if _toxic_pipe is None:
-        try:
-            from transformers import pipeline
-            _toxic_pipe = pipeline(
-                "text-classification",
-                model="unitary/toxic-bert",
-                device=-1,
-                top_k=None,
-            )
-        except Exception:
-            _toxic_pipe = False
-    return _toxic_pipe
-
-
-def is_safe(text: str) -> tuple[bool, str]:
-    if not text or not text.strip():
-        return False, "empty"
-
-    pipe = load_safety_pipe()
-    if pipe is False:
-        return True, "ok"
-
-    try:
-        results = pipe(text[:512])[0]
-        for r in results:
-            label = str(r.get("label", "")).lower()
-            score = float(r.get("score", 0.0))
-            if label != "non-toxic" and score > 0.70:
-                return False, label or "unsafe"
-        return True, "ok"
-    except Exception:
-        return True, "ok"
-
-
-# ---------------------------------------------------------------------
-# Core operations
-# ---------------------------------------------------------------------
-def create_thread(question: str, author: str) -> tuple[Optional[dict], str]:
-    ok, reason = is_safe(question)
-    if not ok:
-        return None, f"Blocked: content flagged as {reason}."
-
-    tid = uuid.uuid4().hex
-    thread = {
-        "id": tid,
-        "question": question,
-        "author": author,
-        "created_at": now_iso(),
-        "messages": [],
-    }
-    save_thread(thread)
-
-    idx = load_index()
-    idx.insert(
-        0,
-        {
-            "id": tid,
-            "title": question[:120],
-            "created_at": thread["created_at"],
-            "author": author,
-            "reply_count": 0,
-        },
-    )
-    save_index(idx)
-
-    emb_idx = load_embed_index()
-    vec = embed_text(question)
-    if vec:
-        emb_idx[tid] = {"question": question, "vector": vec}
-        save_embed_index(emb_idx)
-
-    return thread, "ok"
-
-
-def add_answer(tid: str, text: str, author: str) -> tuple[Optional[dict], str]:
-    ok, reason = is_safe(text)
-    if not ok:
-        return None, f"Blocked: content flagged as {reason}."
-
-    thread = load_thread(tid)
-    if thread is None:
-        return None, "Thread not found."
-
-    version = {
-        "id": uuid.uuid4().hex,
-        "text": text,
-        "author": author,
-        "created_at": now_iso(),
-        "votes": 0,
-        "voters": [],
-    }
-    message = {
-        "id": uuid.uuid4().hex,
-        "versions": [version],
-        "active_version": version["id"],
-        "created_at": version["created_at"],
-    }
-    thread["messages"].append(message)
-    save_thread(thread)
-
-    idx = load_index()
-    for entry in idx:
-        if entry["id"] == tid:
-            entry["reply_count"] = len(thread["messages"])
-            break
-    save_index(idx)
-
-    return thread, "ok"
-
-
-def propose_version(tid: str, msg_id: str, text: str, author: str) -> tuple[Optional[dict], str]:
-    ok, reason = is_safe(text)
-    if not ok:
-        return None, f"Blocked: content flagged as {reason}."
-
-    thread = load_thread(tid)
-    if thread is None:
-        return None, "Thread not found."
-
-    for msg in thread["messages"]:
-        if msg["id"] == msg_id:
-            version = {
-                "id": uuid.uuid4().hex,
-                "text": text,
-                "author": author,
-                "created_at": now_iso(),
-                "votes": 0,
-                "voters": [],
-            }
-            msg["versions"].append(version)
-            save_thread(thread)
-            return thread, "ok"
-
-    return None, "Message not found."
-
-
-def vote_version(tid: str, msg_id: str, version_id: str, username: str) -> tuple[Optional[dict], str]:
-    thread = load_thread(tid)
-    if thread is None:
-        return None, "Thread not found."
-
-    for msg in thread["messages"]:
-        if msg["id"] == msg_id:
-            for v in msg["versions"]:
-                if v["id"] == version_id:
-                    if username in v["voters"]:
-                        return thread, "already_voted"
-                    v["votes"] += 1
-                    v["voters"].append(username)
-                    break
-
-            msg["active_version"] = max(msg["versions"], key=lambda x: x["votes"])["id"]
-            save_thread(thread)
-            return thread, "ok"
-
-    return None, "Message not found."
-
-
-def get_active_version(msg: dict) -> dict:
-    vid = msg.get("active_version")
-    for v in msg.get("versions", []):
-        if v.get("id") == vid:
-            return v
-    return msg.get("versions", [{}])[0]
-
-
-# ---------------------------------------------------------------------
-# API
-# ---------------------------------------------------------------------
-@app.get("/", response_class=HTMLResponse)
-def home(request: Request):
-    return templates.TemplateResponse(
-        "index.html",
-        {
-            "request": request,
-            "app_title": APP_TITLE,
-            "init_json": json.dumps(
-                {
-                    "ok": True,
-                    "username": get_username(request),
-                    "threads": load_index(),
-                },
-                ensure_ascii=False,
-            ),
-        },
-    )
-
-
-@app.get("/api/init")
-def api_init(request: Request):
-    return JSONResponse(
-        {
-            "ok": True,
-            "username": get_username(request),
-            "threads": load_index(),
-        }
-    )
-
-
-@app.post("/api")
-async def api(request: Request):
-    try:
-        payload = await request.json()
-    except Exception:
-        return JSONResponse({"ok": False, "error": "bad payload"})
-
-    action = str(payload.get("action", ""))
-    username = get_username(request, payload)
-
-    if action == "init":
-        return JSONResponse({"ok": True, "username": username, "threads": load_index()})
-
-    if action == "list_threads":
-        return JSONResponse({"ok": True, "threads": load_index()})
-
-    if action == "get_thread":
-        tid = str(payload.get("thread_id", ""))
-        thread = load_thread(tid)
-        if thread is None:
-            return JSONResponse({"ok": False, "error": "not found"})
-        return JSONResponse({"ok": True, "thread": thread})
-
-    if action == "new_thread":
-        if not username or username == "Guest":
-            return JSONResponse({"ok": False, "error": "not signed in"})
-        question = str(payload.get("question", "")).strip()
-        if not question:
-            return JSONResponse({"ok": False, "error": "empty question"})
-        sim = find_similar_thread(question)
-        thread, msg = create_thread(question, username)
-        if thread is None:
-            return JSONResponse({"ok": False, "error": msg})
-        return JSONResponse({"ok": True, "thread": thread, "similar": sim is not None})
-
-    if action == "add_answer":
-        if not username or username == "Guest":
-            return JSONResponse({"ok": False, "error": "not signed in"})
-        tid = str(payload.get("thread_id", ""))
-        text = str(payload.get("text", "")).strip()
-        if not text:
-            return JSONResponse({"ok": False, "error": "empty answer"})
-        thread, msg = add_answer(tid, text, username)
-        if thread is None:
-            return JSONResponse({"ok": False, "error": msg})
-        return JSONResponse({"ok": True, "thread": thread})
-
-    if action == "propose":
-        if not username or username == "Guest":
-            return JSONResponse({"ok": False, "error": "not signed in"})
-        tid = str(payload.get("thread_id", ""))
-        msg_id = str(payload.get("msg_id", ""))
-        text = str(payload.get("text", "")).strip()
-        if not text:
-            return JSONResponse({"ok": False, "error": "empty proposal"})
-        thread, msg = propose_version(tid, msg_id, text, username)
-        if thread is None:
-            return JSONResponse({"ok": False, "error": msg})
-        return JSONResponse({"ok": True, "thread": thread})
-
-    if action == "vote":
-        if not username or username == "Guest":
-            return JSONResponse({"ok": False, "error": "not signed in"})
-        tid = str(payload.get("thread_id", ""))
-        msg_id = str(payload.get("msg_id", ""))
-        version_id = str(payload.get("version_id", ""))
-        thread, msg = vote_version(tid, msg_id, version_id, username)
-        if thread is None:
-            return JSONResponse({"ok": False, "error": msg})
-        if msg == "already_voted":
-            return JSONResponse({"ok": False, "error": "already voted"})
-        return JSONResponse({"ok": True, "thread": thread})
-
-    return JSONResponse({"ok": False, "error": f"unknown action: {action}"})
-
-
-# ---------------------------------------------------------------------
-# Optional healthcheck
-# ---------------------------------------------------------------------
-@app.get("/health")
-def health():
-    return {"ok": True}
-
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=False)
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+import numpy as np
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+# Optional but recommended for similarity search.
+# If sentence-transformers is unavailable, the app still works with a fallback.
+try:
+    from sentence_transformers import SentenceTransformer
+except Exception:  # pragma: no cover
+    SentenceTransformer = None  # type: ignore
+
+try:
+    from sklearn.metrics.pairwise import cosine_similarity
+except Exception:  # pragma: no cover
+    cosine_similarity = None  # type: ignore
+
+
+APP_TITLE = "Human Intelligence"
+DATA_DIR = Path(os.environ.get("DATA_DIR", "/data"))
+THREADS_DIR = DATA_DIR / "threads"
+INDEX_FILE = DATA_DIR / "index.json"
+EMBED_FILE = DATA_DIR / "embeddings.json"
+TEMPLATES_DIR = Path("/app/templates")
+SIMILARITY_THRESHOLD = float(os.environ.get("SIMILARITY_THRESHOLD", "0.82"))
+
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+THREADS_DIR.mkdir(parents=True, exist_ok=True)
+TEMPLATES_DIR.mkdir(parents=True, exist_ok=True)
+
+app = FastAPI(title=APP_TITLE)
+templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
+
+# Serve any public assets you may add later.
+app.mount("/data", StaticFiles(directory=str(DATA_DIR)), name="data")
+
+_embed_model = None
+
+
+# ---------------------------------------------------------------------
+# Utilities
+# ---------------------------------------------------------------------
+def now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def read_json(path: Path, default: Any):
+    if not path.exists():
+        return default
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return default
+
+
+def write_json(path: Path, data: Any) -> None:
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2, default=str), encoding="utf-8")
+    tmp.replace(path)
+
+
+def get_username(request: Request, payload: dict | None = None) -> str:
+    """
+    Priority:
+      1) X-User header
+      2) JSON payload username
+      3) guest
+    This keeps the app simple and deployment-friendly.
+    """
+    header_name = request.headers.get("x-user", "").strip()
+    if header_name:
+        return header_name
+
+    if payload:
+        p_name = str(payload.get("username", "")).strip()
+        if p_name:
+            return p_name
+
+    return "Guest"
+
+
+# ---------------------------------------------------------------------
+# Embeddings / similarity
+# ---------------------------------------------------------------------
+def load_embed_model():
+    global _embed_model
+    if _embed_model is None:
+        if SentenceTransformer is None:
+            return None
+        _embed_model = SentenceTransformer("all-MiniLM-L6-v2")
+    return _embed_model
+
+
+def embed_text(text: str) -> list[float]:
+    model = load_embed_model()
+    if model is None:
+        return []
+
+    vec = model.encode(text, normalize_embeddings=True)
+    return vec.tolist()
+
+
+def load_embed_index() -> dict:
+    return read_json(EMBED_FILE, {})
+
+
+def save_embed_index(idx: dict) -> None:
+    write_json(EMBED_FILE, idx)
+
+
+def find_similar_thread(question: str) -> Optional[tuple[str, float]]:
+    idx = load_embed_index()
+    if not idx:
+        return None
+
+    if cosine_similarity is None:
+        return None
+
+    q_vec = embed_text(question)
+    if not q_vec:
+        return None
+
+    ids = list(idx.keys())
+    vecs = np.array([idx[tid]["vector"] for tid in ids], dtype=float)
+
+    if vecs.size == 0:
+        return None
+
+    sims = cosine_similarity(np.array(q_vec, dtype=float).reshape(1, -1), vecs)[0]
+    best_i = int(np.argmax(sims))
+    score = float(sims[best_i])
+
+    if score >= SIMILARITY_THRESHOLD:
+        return ids[best_i], score
+    return None
+
+
+# ---------------------------------------------------------------------
+# Storage
+# ---------------------------------------------------------------------
+def load_index() -> list[dict]:
+    return read_json(INDEX_FILE, [])
+
+
+def save_index(idx: list[dict]) -> None:
+    write_json(INDEX_FILE, idx)
+
+
+def thread_path(tid: str) -> Path:
+    return THREADS_DIR / f"{tid}.json"
+
+
+def load_thread(tid: str) -> Optional[dict]:
+    return read_json(thread_path(tid), None)
+
+
+def save_thread(thread: dict) -> None:
+    write_json(thread_path(thread["id"]), thread)
+
+
+def ensure_thread_schema(thread: dict) -> dict:
+    thread.setdefault("id", uuid.uuid4().hex)
+    thread.setdefault("question", "")
+    thread.setdefault("author", "Guest")
+    thread.setdefault("created_at", now_iso())
+    thread.setdefault("messages", [])
+    return thread
+
+
+# ---------------------------------------------------------------------
+# Content safety
+# ---------------------------------------------------------------------
+_toxic_pipe = None
+
+def load_safety_pipe():
+    global _toxic_pipe
+    if _toxic_pipe is None:
+        try:
+            from transformers import pipeline
+            _toxic_pipe = pipeline(
+                "text-classification",
+                model="unitary/toxic-bert",
+                device=-1,
+                top_k=None,
+            )
+        except Exception:
+            _toxic_pipe = False
+    return _toxic_pipe
+
+
+def is_safe(text: str) -> tuple[bool, str]:
+    if not text or not text.strip():
+        return False, "empty"
+
+    pipe = load_safety_pipe()
+    if pipe is False:
+        return True, "ok"
+
+    try:
+        results = pipe(text[:512])[0]
+        for r in results:
+            label = str(r.get("label", "")).lower()
+            score = float(r.get("score", 0.0))
+            if label != "non-toxic" and score > 0.70:
+                return False, label or "unsafe"
+        return True, "ok"
+    except Exception:
+        return True, "ok"
+
+
+# ---------------------------------------------------------------------
+# Core operations
+# ---------------------------------------------------------------------
+def create_thread(question: str, author: str) -> tuple[Optional[dict], str]:
+    ok, reason = is_safe(question)
+    if not ok:
+        return None, f"Blocked: content flagged as {reason}."
+
+    tid = uuid.uuid4().hex
+    thread = {
+        "id": tid,
+        "question": question,
+        "author": author,
+        "created_at": now_iso(),
+        "messages": [],
+    }
+    save_thread(thread)
+
+    idx = load_index()
+    idx.insert(
+        0,
+        {
+            "id": tid,
+            "title": question[:120],
+            "created_at": thread["created_at"],
+            "author": author,
+            "reply_count": 0,
+        },
+    )
+    save_index(idx)
+
+    emb_idx = load_embed_index()
+    vec = embed_text(question)
+    if vec:
+        emb_idx[tid] = {"question": question, "vector": vec}
+        save_embed_index(emb_idx)
+
+    return thread, "ok"
+
+
+def add_answer(tid: str, text: str, author: str) -> tuple[Optional[dict], str]:
+    ok, reason = is_safe(text)
+    if not ok:
+        return None, f"Blocked: content flagged as {reason}."
+
+    thread = load_thread(tid)
+    if thread is None:
+        return None, "Thread not found."
+
+    version = {
+        "id": uuid.uuid4().hex,
+        "text": text,
+        "author": author,
+        "created_at": now_iso(),
+        "votes": 0,
+        "voters": [],
+    }
+    message = {
+        "id": uuid.uuid4().hex,
+        "versions": [version],
+        "active_version": version["id"],
+        "created_at": version["created_at"],
+    }
+    thread["messages"].append(message)
+    save_thread(thread)
+
+    idx = load_index()
+    for entry in idx:
+        if entry["id"] == tid:
+            entry["reply_count"] = len(thread["messages"])
+            break
+    save_index(idx)
+
+    return thread, "ok"
+
+
+def propose_version(tid: str, msg_id: str, text: str, author: str) -> tuple[Optional[dict], str]:
+    ok, reason = is_safe(text)
+    if not ok:
+        return None, f"Blocked: content flagged as {reason}."
+
+    thread = load_thread(tid)
+    if thread is None:
+        return None, "Thread not found."
+
+    for msg in thread["messages"]:
+        if msg["id"] == msg_id:
+            version = {
+                "id": uuid.uuid4().hex,
+                "text": text,
+                "author": author,
+                "created_at": now_iso(),
+                "votes": 0,
+                "voters": [],
+            }
+            msg["versions"].append(version)
+            save_thread(thread)
+            return thread, "ok"
+
+    return None, "Message not found."
+
+
+def vote_version(tid: str, msg_id: str, version_id: str, username: str) -> tuple[Optional[dict], str]:
+    thread = load_thread(tid)
+    if thread is None:
+        return None, "Thread not found."
+
+    for msg in thread["messages"]:
+        if msg["id"] == msg_id:
+            for v in msg["versions"]:
+                if v["id"] == version_id:
+                    if username in v["voters"]:
+                        return thread, "already_voted"
+                    v["votes"] += 1
+                    v["voters"].append(username)
+                    break
+
+            msg["active_version"] = max(msg["versions"], key=lambda x: x["votes"])["id"]
+            save_thread(thread)
+            return thread, "ok"
+
+    return None, "Message not found."
+
+
+def get_active_version(msg: dict) -> dict:
+    vid = msg.get("active_version")
+    for v in msg.get("versions", []):
+        if v.get("id") == vid:
+            return v
+    return msg.get("versions", [{}])[0]
+
+
+# ---------------------------------------------------------------------
+# API
+# ---------------------------------------------------------------------
+@app.get("/", response_class=HTMLResponse)
+def home(request: Request):
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "app_title": APP_TITLE,
+            "init_json": json.dumps(
+                {
+                    "ok": True,
+                    "username": get_username(request),
+                    "threads": load_index(),
+                },
+                ensure_ascii=False,
+            ),
+        },
+    )
+
+
+@app.get("/api/init")
+def api_init(request: Request):
+    return JSONResponse(
+        {
+            "ok": True,
+            "username": get_username(request),
+            "threads": load_index(),
+        }
+    )
+
+
+@app.post("/api")
+async def api(request: Request):
+    try:
+        payload = await request.json()
+    except Exception:
+        return JSONResponse({"ok": False, "error": "bad payload"})
+
+    action = str(payload.get("action", ""))
+    username = get_username(request, payload)
+
+    if action == "init":
+        return JSONResponse({"ok": True, "username": username, "threads": load_index()})
+
+    if action == "list_threads":
+        return JSONResponse({"ok": True, "threads": load_index()})
+
+    if action == "get_thread":
+        tid = str(payload.get("thread_id", ""))
+        thread = load_thread(tid)
+        if thread is None:
+            return JSONResponse({"ok": False, "error": "not found"})
+        return JSONResponse({"ok": True, "thread": thread})
+
+    if action == "new_thread":
+        if not username or username == "Guest":
+            return JSONResponse({"ok": False, "error": "not signed in"})
+        question = str(payload.get("question", "")).strip()
+        if not question:
+            return JSONResponse({"ok": False, "error": "empty question"})
+        sim = find_similar_thread(question)
+        thread, msg = create_thread(question, username)
+        if thread is None:
+            return JSONResponse({"ok": False, "error": msg})
+        return JSONResponse({"ok": True, "thread": thread, "similar": sim is not None})
+
+    if action == "add_answer":
+        if not username or username == "Guest":
+            return JSONResponse({"ok": False, "error": "not signed in"})
+        tid = str(payload.get("thread_id", ""))
+        text = str(payload.get("text", "")).strip()
+        if not text:
+            return JSONResponse({"ok": False, "error": "empty answer"})
+        thread, msg = add_answer(tid, text, username)
+        if thread is None:
+            return JSONResponse({"ok": False, "error": msg})
+        return JSONResponse({"ok": True, "thread": thread})
+
+    if action == "propose":
+        if not username or username == "Guest":
+            return JSONResponse({"ok": False, "error": "not signed in"})
+        tid = str(payload.get("thread_id", ""))
+        msg_id = str(payload.get("msg_id", ""))
+        text = str(payload.get("text", "")).strip()
+        if not text:
+            return JSONResponse({"ok": False, "error": "empty proposal"})
+        thread, msg = propose_version(tid, msg_id, text, username)
+        if thread is None:
+            return JSONResponse({"ok": False, "error": msg})
+        return JSONResponse({"ok": True, "thread": thread})
+
+    if action == "vote":
+        if not username or username == "Guest":
+            return JSONResponse({"ok": False, "error": "not signed in"})
+        tid = str(payload.get("thread_id", ""))
+        msg_id = str(payload.get("msg_id", ""))
+        version_id = str(payload.get("version_id", ""))
+        thread, msg = vote_version(tid, msg_id, version_id, username)
+        if thread is None:
+            return JSONResponse({"ok": False, "error": msg})
+        if msg == "already_voted":
+            return JSONResponse({"ok": False, "error": "already voted"})
+        return JSONResponse({"ok": True, "thread": thread})
+
+    return JSONResponse({"ok": False, "error": f"unknown action: {action}"})
+
+
+# ---------------------------------------------------------------------
+# Optional healthcheck
+# ---------------------------------------------------------------------
+@app.get("/health")
+def health():
+    return {"ok": True}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=False)