feat: chat intégré par fichier — panneau latéral, historique, temps réel SSE #169

- Store backend `backend/file_chat.py` : messages JSON par (vault, path)
  sous `data/chats/` (nom hashé SHA-256 → traversal impossible), plafond
  500 messages, texte tronqué à 4000 caractères, écriture atomique.
- Routes `GET/POST /api/file/{vault}/chat` : auth + accès vault +
  `resolve_safe_path`, schémas Pydantic (`response_model`), broadcast SSE
  `chat_message` sur le transport existant (#62) — pas de second WebSocket.
- Panneau latéral `frontend/js/filechat.js` : bouton 💬 dans la toolbar
  fichier, historique chronologique, envoi optimiste + dédoublonnage par id,
  toast « Nouveau message » si le panneau est fermé/autre fichier.
- Relais SSE dans `sync.js` (import dynamique), CSS bloc #169 (plein écran
  ≤ 768 px, input 16 px anti-zoom), i18n FR/EN (10 clés `chat.*`).
- Tests : `tests/test_file_chat.py` (15) + `tests/frontend/filechat.test.mjs`
  (6, ajouté au pipeline CI), regex toolbar-order mise à jour.
- Docs : CHANGELOG [Unreleased], ROADMAP #169 → livré + index, fiche
  `docs/features/file-chat-169.md`, guide « Discuter d'un fichier ».

backend/file_chat.py

@@ -0,0 +1,84 @@
+# backend/file_chat.py — historique de discussion par fichier (#169)
+"""Per-file chat history persisted under ``data/chats/``.
+
+One JSON document per ``(vault, path)`` pair, keyed by a SHA-256 of both so
+the filename never carries user-controlled path separators. Writes are
+atomic (tmp + move) and the message list is capped at
+:data:`MAX_MESSAGES` to bound growth.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import shutil
+import time
+import uuid
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger("obsigate.file_chat")
+
+CHAT_DIR = Path("data/chats")
+MAX_MESSAGES = 500  # retention ceiling per file (oldest dropped first)
+MAX_TEXT = 4000  # characters per message
+
+
+def _chat_file(vault: str, path: str) -> Path:
+    """Return the chat file for *(vault, path)* (hashed, traversal-proof)."""
+    CHAT_DIR.mkdir(parents=True, exist_ok=True)
+    key = hashlib.sha256(f"{vault}\0{path}".encode()).hexdigest()[:32]
+    return CHAT_DIR / f"{key}.json"
+
+
+def _read(vault: str, path: str) -> dict[str, Any]:
+    """Load the raw chat document (empty structure when missing/corrupt)."""
+    file = _chat_file(vault, path)
+    if not file.exists():
+        return {"vault": vault, "path": path, "messages": []}
+    try:
+        doc = json.loads(file.read_text(encoding="utf-8"))
+        if not isinstance(doc.get("messages"), list):
+            raise TypeError("messages is not a list")  # caught by the handler below
+        return doc
+    except Exception as e:
+        logger.error("Failed to read chat for %s/%s: %s", vault, path, e)
+        return {"vault": vault, "path": path, "messages": []}
+
+
+def _write(file: Path, doc: dict[str, Any]) -> None:
+    """Atomically persist *doc* (tmp file + rename)."""
+    try:
+        tmp = file.with_suffix(".tmp")
+        tmp.write_text(json.dumps(doc, ensure_ascii=False, indent=1), encoding="utf-8")
+        shutil.move(str(tmp), str(file))
+    except Exception as e:
+        logger.error("Failed to write chat %s: %s", file.name, e)
+
+
+def get_messages(vault: str, path: str) -> list[dict[str, Any]]:
+    """Return the chat history for *(vault, path)* (chronological)."""
+    return list(_read(vault, path).get("messages", []))
+
+
+def add_message(vault: str, path: str, user: str, text: str) -> dict[str, Any]:
+    """Append a message and persist it. Returns the stored message.
+
+    The list is capped at :data:`MAX_MESSAGES` (oldest dropped first).
+    """
+    text = (text or "").strip()[:MAX_TEXT]
+    msg = {
+        "id": uuid.uuid4().hex[:12],
+        "user": user or "anonyme",
+        "text": text,
+        "ts": time.time(),
+    }
+    doc = _read(vault, path)
+    messages = list(doc.get("messages", []))
+    messages.append(msg)
+    if len(messages) > MAX_MESSAGES:
+        messages = messages[-MAX_MESSAGES:]
+    doc["messages"] = messages
+    _write(_chat_file(vault, path), doc)
+    return msg

backend/main.py

@@ -509,6 +509,7 @@ from backend.routers.config import _load_config
 from backend.routers.config import router as config_router
 from backend.routers.conflicts import router as conflicts_router
 from backend.routers.duplicates import router as duplicates_router
+from backend.routers.file_chat import router as file_chat_router
 from backend.routers.files_media import router as files_media_router
 from backend.routers.files_read import router as files_read_router
 from backend.routers.files_write import router as files_write_router
@@ -534,6 +535,7 @@ app.include_router(search_router)  # ROADMAP #85 T5 — Search
 app.include_router(backups_router)  # ROADMAP #85 T4 — Backups
 app.include_router(conflicts_router)  # ROADMAP #85 T8 — Conflicts
 app.include_router(config_router)  # ROADMAP #85 T7 — Config
+app.include_router(file_chat_router)  # ROADMAP #169 — Chat par fichier
 app.include_router(files_read_router)  # ROADMAP #85 T6a — Files read
 app.include_router(files_media_router)  # ROADMAP #85 T6c — Media/export
 app.include_router(files_write_router)  # ROADMAP #85 T6b — Files write

backend/routers/file_chat.py

@@ -0,0 +1,65 @@
+# backend/routers/file_chat.py — chat par fichier (#169)
+"""Per-file chat endpoints: history read + message post with SSE fan-out.
+
+GET/POST ``/api/file/{vault_name}/chat`` — auth + vault access + path
+traversal check (``resolve_safe_path`` raises ``ServiceError`` mapped by
+the app-level handler). A posted message is broadcast on the existing
+SSE channel (``chat_message``) so every connected client updates live
+without a second WebSocket.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, Body, Depends, HTTPException
+
+from backend import file_chat as _store
+from backend.auth.middleware import check_vault_access, require_auth
+from backend.indexer import get_vault_data
+from backend.schemas import ChatHistoryResponse, ChatMessageResponse
+from backend.services.paths import resolve_safe_path
+from backend.sse import sse_manager
+
+router = APIRouter()  # tags dérivés de `tag_for_path` → « Files »
+
+
+def _check(vault_name: str, path: str, current_user: dict[str, Any]) -> None:
+    """Authz + traversal guard shared by both verbs."""
+    if not check_vault_access(vault_name, current_user):
+        raise HTTPException(403, f"Accès refusé à la vault '{vault_name}'")
+    vault_data = get_vault_data(vault_name)
+    if not vault_data:
+        raise HTTPException(404, "Vault not found")
+    resolve_safe_path(Path(vault_data["path"]), path)  # ServiceError → 403/500
+
+
+@router.get("/api/file/{vault_name}/chat", response_model=ChatHistoryResponse)
+async def api_file_chat_history(
+    vault_name: str,
+    path: str,
+    current_user: dict[str, Any] = Depends(require_auth),
+):
+    """Return the chat history for a file (chronological)."""
+    _check(vault_name, path, current_user)
+    return {"messages": _store.get_messages(vault_name, path)}
+
+
+@router.post("/api/file/{vault_name}/chat", response_model=ChatMessageResponse)
+async def api_file_chat_post(
+    vault_name: str,
+    body: dict[str, Any] = Body(...),
+    current_user: dict[str, Any] = Depends(require_auth),
+):
+    """Post a chat message and broadcast it on SSE (``chat_message``)."""
+    path = str(body.get("path") or "")
+    text = str(body.get("text") or "")
+    if not path:
+        raise HTTPException(400, "path is required")
+    if not text.strip():
+        raise HTTPException(400, "text is required")
+    _check(vault_name, path, current_user)
+    msg = _store.add_message(vault_name, path, current_user.get("username", ""), text)
+    await sse_manager.broadcast("chat_message", {"vault": vault_name, "path": path, "message": msg})
+    return {"message": msg, "status": "ok"}

backend/schemas.py

@@ -151,6 +151,28 @@ class BacklinksResponse(BaseModel):
     total: int
 
 
+class ChatMessageItem(BaseModel):
+    """One chat message (``GET/POST /api/file/{vault}/chat``)."""
+
+    id: str = Field(description="Message id")
+    user: str = Field(description="Author username")
+    text: str = Field(description="Message body")
+    ts: float = Field(description="Unix timestamp")
+
+
+class ChatHistoryResponse(BaseModel):
+    """Response for ``GET /api/file/{vault}/chat``."""
+
+    messages: list[ChatMessageItem] = Field(description="Messages, chronological")
+
+
+class ChatMessageResponse(BaseModel):
+    """Response for ``POST /api/file/{vault}/chat``."""
+
+    message: ChatMessageItem
+    status: str = Field(description="'ok'")
+
+
 class BackupsListResponse(BaseModel):
     """Response for ``GET /api/backups``."""