Sales Trainer v0.1: corporate sales-training simulator (Flask+Vue, 15 personas, chat simulator, judge, analytics)

- Auth/roles (no self-reg), admin user provision, JWT
- Analyze: sales kit + initial pain-fit from form/upload
- Persona generator: 15 personas (5/tier) w/ pain variety, negotiation, init mode, channel, latent/revealable, wrong_text special
- Chat simulator: per-mode initiation, one-shot, hidden signals, judge-LLM debrief+coaching
- Trainee loop: win/lose board, weak-areas, user-generated personas
- Admin analytics; EN+TH Vue SPA served by Flask
- Deploy: Dockerfile, docker-compose, README, eng-log + HANDOFF
- Tests (mock LLM): m0/m1/routes/e2e all pass

backend/app/storage/store.py

@@ -0,0 +1,138 @@
+"""Durable filesystem JSON store.
+
+Each entity is stored as its own JSON file under a per-type directory. Writes are
+atomic (temp file + os.replace + fsync). Thread-safe via a per-path lock.
+"""
+from __future__ import annotations
+
+import json
+import os
+import threading
+import uuid
+from pathlib import Path
+from typing import Any, Callable
+
+from ..config import Config
+
+
+class StoreError(Exception):
+    pass
+
+
+class _Locks:
+    def __init__(self) -> None:
+        self._locks: dict[str, threading.RLock] = {}
+        self._guard = threading.Lock()
+
+    def get(self, key: str) -> threading.RLock:
+        with self._guard:
+            if key not in self._locks:
+                self._locks[key] = threading.RLock()
+            return self._locks[key]
+
+
+_locks = _Locks()
+
+
+def new_id(prefix: str) -> str:
+    return f"{prefix}-{uuid.uuid4().hex[:12]}"
+
+
+def _atomic_write(path: Path, value: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp")
+    try:
+        with tmp.open("w", encoding="utf-8") as fh:
+            json.dump(value, fh, ensure_ascii=False, indent=2)
+            fh.flush()
+            os.fsync(fh.fileno())
+        os.replace(tmp, path)
+    finally:
+        if tmp.exists():
+            try:
+                tmp.unlink()
+            except OSError:
+                pass
+
+
+def _read_json(path: Path) -> Any:
+    with path.open("r", encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+class JsonStore:
+    """Simple JSON-file collection with CRUD + locking."""
+
+    def __init__(self, root: Path, *, key_attr: str = "id") -> None:
+        self.root = root
+        self.key_attr = key_attr
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def _path(self, key: str) -> Path:
+        if not key or "/" in key or ".." in key:
+            raise StoreError("invalid id")
+        return self.root / f"{key}.json"
+
+    def create(self, value: dict[str, Any], *, key: str | None = None) -> dict[str, Any]:
+        key = key or value.get(self.key_attr) or new_id(self.key_attr)
+        if self.key_attr not in value:
+            value = dict(value)
+            value[self.key_attr] = key
+        path = self._path(key)
+        lock = _locks.get(str(path))
+        with lock:
+            if path.exists():
+                raise StoreError(f"already exists: {key}")
+            _atomic_write(path, value)
+        return value
+
+    def get(self, key: str) -> dict[str, Any]:
+        path = self._path(key)
+        lock = _locks.get(str(path))
+        with lock:
+            if not path.exists():
+                raise StoreError(f"not found: {key}")
+            return _read_json(path)
+
+    def get_or_none(self, key: str) -> dict[str, Any] | None:
+        try:
+            return self.get(key)
+        except StoreError:
+            return None
+
+    def update(self, key: str, **fields: Any) -> dict[str, Any]:
+        path = self._path(key)
+        lock = _locks.get(str(path))
+        with lock:
+            if not path.exists():
+                raise StoreError(f"not found: {key}")
+            cur = _read_json(path)
+            cur.update(fields)
+            _atomic_write(path, cur)
+            return cur
+
+    def replace(self, key: str, value: dict[str, Any]) -> dict[str, Any]:
+        path = self._path(key)
+        lock = _locks.get(str(path))
+        with lock:
+            _atomic_write(path, value)
+            return value
+
+    def delete(self, key: str) -> None:
+        path = self._path(key)
+        lock = _locks.get(str(path))
+        with lock:
+            if path.exists():
+                path.unlink()
+
+    def all(self) -> list[dict[str, Any]]:
+        out: list[dict[str, Any]] = []
+        for path in sorted(self.root.glob("*.json")):
+            try:
+                out.append(_read_json(path))
+            except (OSError, ValueError):
+                continue
+        return out
+
+    def where(self, pred: Callable[[dict[str, Any]], bool]) -> list[dict[str, Any]]:
+        return [row for row in self.all() if pred(row)]