API: the support page becomes a web app, React with Mantine and FastAPI (D-137)

Same features as the local page; agents, tools, prompts and knowledge unchanged.
- API/web/: React (Vite) with Mantine components: collapsible sidebar, mobile drawer,
  cards, notifications, dark mode
- API/support/serveur.py: FastAPI serves the built page and /api; agent events pushed
  by server-sent events (/api/flux) instead of polling
- data, cases folder and port set by AIMSIGHT_DATA, AIMSIGHT_CASES, AIMSIGHT_PORT
- check.py: server check (host guard, analyse, stream, PDF) with a fake client
- old page.html removed

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-05 14:03:52 +01:00
1 parent eb10a6b735
commit b0245c4067
17 files changed
+1666 -263

No files matched your search

+2
View File
@@ -3,3 +3,5 @@
__pycache__/
tools/typst/documents/
tools/typst/build/
web/node_modules/
web/dist/
+12 -3
View File
@@ -22,13 +22,21 @@ LANGSMITH_ENDPOINT=https://eu.api.smith.langchain.com
LANGSMITH_PROJECT=Support
```
## Lancer la page
## Lancer la web app (D-137)
Une fois, et après chaque changement de la page : construire le front React (Node 22).
```bash
cd API/web && npm install && npm run build
```
Puis le serveur, qui sert la page et l'API :
```bash
API/.venv/bin/python API/support/serveur.py
```
La page s'ouvre sur `http://127.0.0.1:8770`. Une séance à la fois ; elle est gardée dans `cases/<date>_<STATION>_<sujet>/`.
La page s'ouvre sur `http://127.0.0.1:8770`. Une séance à la fois ; elle est gardée dans `cases/<date>_<STATION>_<sujet>/`. Réglages par variables : `AIMSIGHT_DATA` (données, défaut `data/` du dépôt), `AIMSIGHT_CASES` (séances, défaut `API/cases/`), `AIMSIGHT_PORT` (8770). Pour travailler sur la page : `npm run dev` dans `API/web/` (http://localhost:5173, rechargée à chaque enregistrement), le serveur Python lancé à côté.
## Les dossiers
@@ -36,5 +44,6 @@ La page s'ouvre sur `http://127.0.0.1:8770`. Une séance à la fois ; elle est g
- `prompts/` : les prompts système du support et de l'analyste (en balises) ; le savoir de `knowledge/` y est ajouté au chargement.
- `knowledge/` : ce que lisent les agents, copié du projet (pour l'analyste, les cartes dans le prompt, le reste à la demande par `lire_document`, D-136) : `analyste/` (familles, carte des étiquettes, connaissances, outils de lecture, règles de preuve), `support/` (présentation, modèle Typst, rédaction).
- `tools/` : copies des outils de lecture (`agent-tools/`), des détecteurs (`detectors/`), des figures (`figures/`), de la fabrique Typst (`typst/brand/`) ; `journal.py`, les événements des détecteurs avec leurs capteurs ; `stabilite.py`, la médiane de corr_y jour par jour et son étendue, par cible.
- `support/` : le serveur, la page, les deux agents, leurs outils, `check.py` (vérifications : `API/.venv/bin/python API/support/check.py`).
- `web/` : la page React, ses composants de Mantine (MIT : en-tête, barre latérale repliable, tiroir sur téléphone, cartes, notifications, mode sombre) ; `src/App.jsx` : la saisie, les deux fils, le rapport ; `src/main.jsx` : le thème (bleu #5383ff, Roboto) ; `dist/` et `node_modules/` hors de git.
- `support/` : le serveur FastAPI, les deux agents, leurs outils, `check.py` (vérifications : `API/.venv/bin/python API/support/check.py`).
- `cases/` : une séance par dossier : le mail, le contexte, les deux historiques, les figures, le source Typst, les PDF par version. Contient des mails et des images de clients.
+2
View File
@@ -1,3 +1,5 @@
anthropic
langsmith
matplotlib
fastapi
uvicorn
+57 -1
View File
@@ -262,7 +262,63 @@ def check_stations_dans_la_seance():
assert "stations" in AVEC_SORTIE
CHECKS = [check_lire_document, check_cartes, check_stabilite, check_image_proche, check_max_tokens, check_sans_repli, check_capture_reduite, check_stations_dans_la_seance, check_boucle, check_erreur, check_cout, check_source, check_outil_qui_leve, check_lecture_refusee,
def check_serveur():
# le vrai serveur sur un port libre, une séance au faux client : la garde, l'analyse, le flux, le PDF absent
import json
import shutil
import socket
import threading
import time
import urllib.request
from urllib.error import HTTPError
import uvicorn
import seance
import serveur
with socket.socket() as so:
so.bind(("127.0.0.1", 0))
port = so.getsockname()[1]
cases = seance.CASES
seance.CASES, serveur.CLIENT = seance_temporaire(), FauxClient(reponse([Bloc(type="text", text="Bonjour Marc")], "end_turn"))
srv = uvicorn.Server(uvicorn.Config(serveur.app, host="127.0.0.1", port=port, log_level="error"))
threading.Thread(target=srv.run, daemon=True).start()
while not srv.started:
time.sleep(0.05)
base = f"http://127.0.0.1:{port}"
def appel(chemin, corps=None, entetes=None):
r = urllib.request.Request(base + chemin, json.dumps(corps).encode() if corps is not None else None,
{"Content-Type": "application/json", **(entetes or {})})
try:
with urllib.request.urlopen(r) as rep:
return rep.status
except HTTPError as e:
return e.code
try:
assert appel("/api/pdf", entetes={"Host": "evil.example:80"}) == 403
assert appel("/api/analyser", {"mail": "x"}, {"Content-Type": "text/plain"}) == 403
assert appel("/api/analyser", {"mail": " "}) == 400
assert appel("/api/analyser", {"mail": "Bonjour", "contexte": "", "images": []}) == 200
with urllib.request.urlopen(base + "/api/flux", timeout=10) as f:
premier, textes = None, []
for ligne in f:
if ligne.startswith(b"data: "):
m = json.loads(ligne[6:])
premier = premier or m
textes += [e["texte"] for e in m["evenements"]]
if "Bonjour Marc" in textes and not m["occupe"]["support"]:
break
assert premier["depuis"] == 0 and premier["id"], premier
assert appel("/api/pdf") == 404
(serveur.etat["seance"].dossier / "v1.pdf").write_bytes(b"%PDF-1.4")
with urllib.request.urlopen(base + "/api/pdf") as rep:
assert rep.read() == b"%PDF-1.4" and rep.headers["Content-Disposition"].startswith("inline"), rep.headers
finally:
srv.should_exit = True
shutil.rmtree(seance.CASES)
seance.CASES = cases
CHECKS = [check_serveur, check_lire_document, check_cartes, check_stabilite, check_image_proche, check_max_tokens, check_sans_repli, check_capture_reduite, check_stations_dans_la_seance, check_boucle, check_erreur, check_cout, check_source, check_outil_qui_leve, check_lecture_refusee,
check_chemin, check_station_absente, check_detecteurs, check_plafond, check_image, check_compiler]
if __name__ == "__main__":
-170
View File
@@ -1,170 +0,0 @@
<!doctype html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Support AIMsight</title>
<style>
:root { --fond: #f6f7f9; --carte: #fff; --texte: #1d232b; --doux: #6b7480; --bord: #d9dde3;
--support: #e8eefc; --analyste: #e7f5ec; --marc: #fdf0e3; --erreur: #b3261e; --accent: #2457c5; }
* { box-sizing: border-box; }
body { margin: 0; padding: 16px; font: 14px/1.45 system-ui, sans-serif; background: var(--fond); color: var(--texte); }
h1 { font-size: 18px; margin: 0 0 12px; }
.carte { background: var(--carte); border: 1px solid var(--bord); border-radius: 8px; padding: 12px; }
.entree { display: grid; grid-template-columns: 2fr 1fr auto; gap: 12px; align-items: start; }
label { font-size: 12px; color: var(--doux); display: block; margin-bottom: 4px; }
textarea { width: 100%; border: 1px solid var(--bord); border-radius: 6px; padding: 8px; font: inherit; resize: vertical; }
#mail { min-height: 140px; } #contexte { min-height: 140px; }
button { font: inherit; padding: 8px 16px; border: 0; border-radius: 6px; background: var(--accent); color: #fff; cursor: pointer; }
button:disabled { background: var(--bord); color: var(--doux); cursor: default; }
.cote { display: flex; flex-direction: column; gap: 8px; min-width: 150px; }
#cout { font-size: 12px; color: var(--doux); white-space: pre; }
#vignettes img { height: 48px; margin: 4px 4px 0 0; border: 1px solid var(--bord); border-radius: 4px; }
.fils { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; margin: 12px 0; }
.fil { display: flex; flex-direction: column; height: 60vh; }
.fil h2 { font-size: 14px; margin: 0 0 8px; display: flex; justify-content: space-between; }
.etat { font-weight: normal; color: var(--doux); font-size: 12px; }
.messages { flex: 1; overflow-y: auto; display: flex; flex-direction: column; gap: 6px; padding-right: 4px; }
.m { padding: 8px 10px; border-radius: 6px; white-space: pre-wrap; overflow-wrap: anywhere; }
.m.support { background: var(--support); } .m.analyste { background: var(--analyste); }
.m.marc { background: var(--marc); align-self: flex-end; max-width: 85%; }
.m.relai { background: var(--support); border-left: 3px solid var(--accent); }
.m .qui { font-size: 11px; color: var(--doux); display: block; margin-bottom: 2px; }
.outil { font-size: 12px; color: var(--doux); font-family: ui-monospace, monospace; overflow-wrap: anywhere; }
.erreur { color: var(--erreur); font-size: 12px; }
.saisie { display: flex; gap: 8px; margin-top: 8px; }
.saisie textarea { min-height: 44px; height: 44px; }
.rapport { display: flex; flex-direction: column; gap: 8px; }
.rapport .barre { display: flex; justify-content: space-between; align-items: center; }
iframe { width: 100%; height: 75vh; border: 1px solid var(--bord); border-radius: 6px; background: #fff; }
.vide { color: var(--doux); padding: 24px; text-align: center; }
@media (max-width: 900px) { .entree, .fils { grid-template-columns: 1fr; } }
</style>
</head>
<body>
<h1>Support AIMsight</h1>
<div class="carte entree">
<div>
<label for="mail">Mail du client (texte ; colle les captures ici, elles s'ajoutent en vignettes)</label>
<textarea id="mail" placeholder="Bonjour, …"></textarea>
<div id="vignettes"></div>
</div>
<div>
<label for="contexte">Ton contexte (station, plage, ce que tu sais du cas)</label>
<textarea id="contexte"></textarea>
</div>
<div class="cote">
<button id="analyser">Analyser</button>
<div id="cout"></div>
<div id="dossier" class="outil"></div>
</div>
</div>
<div class="fils">
<div class="carte fil">
<h2>Support <span class="etat" id="etat-support"></span></h2>
<div class="messages" id="fil-support"></div>
<div class="saisie"><textarea id="saisie-support" placeholder="Au support…"></textarea><button data-agent="support">Envoyer</button></div>
</div>
<div class="carte fil">
<h2>Analyste <span class="etat" id="etat-analyste"></span></h2>
<div class="messages" id="fil-analyste"></div>
<div class="saisie"><textarea id="saisie-analyste" placeholder="À l'analyste…"></textarea><button data-agent="analyste">Envoyer</button></div>
</div>
</div>
<div class="carte rapport">
<div class="barre"><strong>Rapport <span id="version"></span></strong><a id="telecharger" hidden><button>Télécharger le PDF</button></a></div>
<div id="pdf" class="vide">Pas encore de PDF.</div>
</div>
<script>
const images = [];
let n = 0, version = null, id = null;
document.getElementById("mail").addEventListener("paste", ev => {
for (const item of ev.clipboardData.items) {
if (!item.type.startsWith("image/")) continue;
const lecteur = new FileReader();
lecteur.onload = () => {
images.push({ nom: `capture-${images.length + 1}`, type: item.type, base64: lecteur.result.split(",")[1] });
const img = document.createElement("img"); img.src = lecteur.result;
document.getElementById("vignettes").append(img);
};
lecteur.readAsDataURL(item.getAsFile());
}
});
async function poster(chemin, corps) {
const r = await fetch(chemin, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(corps) });
if (!r.ok) alert((await r.json()).erreur);
return r.ok;
}
document.getElementById("analyser").onclick = async () => {
const mail = document.getElementById("mail").value, contexte = document.getElementById("contexte").value;
if (!mail.trim()) return alert("Colle d'abord le mail du client.");
if (await poster("/analyser", { mail, contexte, images })) {
images.length = 0; document.getElementById("vignettes").innerHTML = ""; // pas de captures d'un client à l'autre
}
};
for (const b of document.querySelectorAll(".saisie button")) {
b.onclick = async () => {
const agent = b.dataset.agent, zone = document.getElementById(`saisie-${agent}`);
if (zone.value.trim() && await poster("/message", { agent, texte: zone.value })) zone.value = "";
};
}
function ajouter(fil, classe, texte, qui) {
const d = document.createElement("div"); d.className = classe;
if (qui) { const q = document.createElement("span"); q.className = "qui"; q.textContent = qui; d.append(q); }
d.append(document.createTextNode(texte));
const f = document.getElementById(`fil-${fil}`); f.append(d); f.scrollTop = f.scrollHeight;
}
function montrer(e) {
if (e.type === "cout") return;
if (e.type === "outil") return ajouter(e.agent, "outil", "→ " + e.texte);
if (e.type === "erreur") return ajouter(e.agent, "erreur", "Erreur : " + e.texte);
if (e.type === "entree") {
if (e.source === "marc") return ajouter(e.agent, "m marc", e.texte.replace(/^<mail>\n?|\n?<\/mail>[\s\S]*$/g, ""), "Toi");
return ajouter(e.agent, "m relai", e.texte, "Demande du support");
}
ajouter(e.agent, `m ${e.agent}`, e.texte, e.agent === "support" ? "Support" : "Analyste");
}
async function interroger() {
try {
let r = await (await fetch(`/evenements?depuis=${n}`)).json();
if (r.id && r.id !== id) { // une nouvelle séance : tout repartir de zéro (l'id ne change pas quand le dossier est renommé)
id = r.id; version = null;
for (const id of ["fil-support", "fil-analyste"]) document.getElementById(id).innerHTML = "";
document.getElementById("pdf").outerHTML = `<div id="pdf" class="vide">Pas encore de PDF.</div>`;
document.getElementById("version").textContent = ""; document.getElementById("telecharger").hidden = true;
r = await (await fetch(`/evenements?depuis=0`)).json();
}
r.evenements.forEach(montrer); n = r.n;
if (r.cout) document.getElementById("cout").textContent =
`Support ${r.cout.support.toFixed(2)} $\nAnalyste ${r.cout.analyste.toFixed(2)} $\nTotal ${r.cout.total.toFixed(2)} $`;
document.getElementById("dossier").textContent = r.dossier || "";
for (const a of ["support", "analyste"]) {
document.getElementById(`etat-${a}`).textContent = r.occupe[a] ? "occupé…" : "";
document.getElementById(`saisie-${a}`).disabled = r.occupe[a];
document.querySelector(`button[data-agent=${a}]`).disabled = r.occupe[a] || !r.dossier;
}
document.getElementById("analyser").disabled = r.occupe.support || r.occupe.analyste;
if (r.version && r.version !== version) {
version = r.version;
document.getElementById("version").textContent = `(${version.replace(".pdf", "")})`;
document.getElementById("pdf").outerHTML = `<iframe id="pdf" src="/pdf?v=${version}"></iframe>`;
const a = document.getElementById("telecharger"); a.href = `/pdf?v=${version}`; a.download = `${r.dossier}_${version}`; a.hidden = false;
}
} catch (e) { /* serveur arrêté : on réessaie */ }
setTimeout(interroger, 1000);
}
interroger();
</script>
</body>
</html>
+1 -1
View File
@@ -8,7 +8,7 @@ from pathlib import Path
from typing import Callable
API = Path(__file__).resolve().parents[1]
CASES = API / "cases"
CASES = Path(os.environ.get("AIMSIGHT_CASES", API / "cases")).resolve()
TYPES_IMAGE = {"image/png", "image/jpeg", "image/gif", "image/webp"}
+107 -86
View File
@@ -1,26 +1,35 @@
"""La page support : API/.venv/bin/python API/support/serveur.py → http://127.0.0.1:8770
"""La web app support : API/.venv/bin/python API/support/serveur.py → http://127.0.0.1:8770
Une séance à la fois, en mémoire ; la page interroge /evenements chaque seconde.
Le serveur FastAPI sert la page React construite (API/web/dist, `npm run build` dans API/web) et l'API sous /api.
Une séance à la fois, en mémoire ; /api/flux pousse à la page les événements des agents (server-sent events).
Réglages : AIMSIGHT_DATA (données), AIMSIGHT_CASES (séances), AIMSIGHT_PORT (port, 8770).
"""
import asyncio
import base64
import json
import os
import platform
import subprocess
import sys
import threading
import webbrowser
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import parse_qs, urlparse
import uvicorn
from fastapi import FastAPI, Request
from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
from fastapi.staticfiles import StaticFiles
sys.path.insert(0, str(Path(__file__).resolve().parent))
from seance import Seance, donnees_par_defaut # noqa: E402
from seance import API, Seance, donnees_par_defaut # noqa: E402
PORT = 8770
HOTES = {f"127.0.0.1:{PORT}", f"localhost:{PORT}"} # contre le DNS rebinding : un autre site ne lit ni mails ni PDF
PAGE = Path(__file__).resolve().parent / "page.html"
PORT = int(os.environ.get("AIMSIGHT_PORT", 8770))
HOTES = {"127.0.0.1", "localhost"} # contre le DNS rebinding : un autre site ne lit ni mails ni PDF
PAGE = API / "web" / "dist"
CLIENT = None # le client Anthropic des séances ; None : le vrai (check.py y met un faux)
verrou = threading.Lock()
etat = {"seance": None, "evenements": []}
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
def journal(e: dict) -> None:
@@ -37,85 +46,98 @@ def en_fond(f, *args):
threading.Thread(target=lancer, daemon=True).start()
class Serveur(BaseHTTPRequestHandler):
def log_message(self, *_):
pass
def erreur(code: int, texte: str) -> JSONResponse:
return JSONResponse({"erreur": texte}, code)
def _envoyer(self, code: int, corps: bytes, type_: str = "application/json", plus: dict | None = None):
self.send_response(code)
self.send_header("Content-Type", type_)
self.send_header("Content-Length", str(len(corps)))
for k, v in (plus or {}).items():
self.send_header(k, v)
self.end_headers()
self.wfile.write(corps)
def _json(self, code: int, obj) -> None:
self._envoyer(code, json.dumps(obj, ensure_ascii=False).encode())
@app.middleware("http")
async def garde(request: Request, suite):
"""Seule la page elle-même parle au serveur : bon Host ; en POST, un JSON déclaré (une page d'un autre site ne
peut l'envoyer sans requête préalable, à laquelle le serveur ne répond pas)."""
hote = request.headers.get("host", "").rsplit(":", 1)[0]
if hote not in HOTES or (request.method == "POST"
and not request.headers.get("content-type", "").startswith("application/json")):
return erreur(403, "requête refusée")
return await suite(request)
def _refuse(self, post: bool = False) -> bool:
"""Seule la page elle-même parle au serveur : bon Host ; en POST, un JSON déclaré (une page d'un autre site ne
peut l'envoyer sans requête préalable, à laquelle le serveur ne répond pas)."""
if self.headers.get("Host") not in HOTES or (
post and not self.headers.get("Content-Type", "").startswith("application/json")):
self._json(403, {"erreur": "requête refusée"})
return True
return False
def do_GET(self):
if self._refuse():
return
url = urlparse(self.path)
s = etat["seance"]
if url.path == "/":
return self._envoyer(200, PAGE.read_bytes(), "text/html; charset=utf-8")
if url.path == "/evenements":
depuis = int(parse_qs(url.query).get("depuis", ["0"])[0])
with verrou:
evs = etat["evenements"][depuis:]
n = len(etat["evenements"])
v = s.derniere_version() if s else None
return self._json(200, {"evenements": evs, "n": n, "cout": s.cout() if s else None,
"version": v.name if v else None, "dossier": s.dossier.name if s else None,
"id": s.id if s else None,
"occupe": {a: bool(s and s.occupe(a)) for a in ("support", "analyste")}})
if url.path == "/pdf":
v = s.derniere_version() if s else None
if not v:
return self._json(404, {"erreur": "pas encore de PDF"})
nom = f"{s.dossier.name}_{v.name}"
return self._envoyer(200, v.read_bytes(), "application/pdf",
{"Content-Disposition": f'inline; filename="{nom}"'})
self._json(404, {"erreur": url.path})
def instantane(depuis: int) -> dict:
s = etat["seance"]
with verrou:
evs, n = etat["evenements"][depuis:], len(etat["evenements"])
v = s.derniere_version() if s else None
return {"evenements": evs, "n": n, "cout": s.cout() if s else None, "version": v.name if v else None,
"dossier": s.dossier.name if s else None, "id": s.id if s else None,
"occupe": {a: bool(s and s.occupe(a)) for a in ("support", "analyste")}}
def do_POST(self):
if self._refuse(post=True):
return
corps = json.loads(self.rfile.read(int(self.headers.get("Content-Length", 0))) or b"{}")
s = etat["seance"]
if self.path == "/analyser":
if s and (s.occupe("support") or s.occupe("analyste")):
return self._json(409, {"erreur": "une séance travaille encore"})
if not corps.get("mail", "").strip():
return self._json(400, {"erreur": "le mail est vide"})
images = [(i["type"], base64.b64decode(i["base64"])) for i in corps.get("images", [])]
with verrou:
etat["evenements"] = []
etat["seance"] = s = Seance(corps["mail"], images, corps.get("contexte", ""), donnees_par_defaut(),
journal)
en_fond(s.demarrer)
return self._json(200, {"dossier": s.dossier.name})
if self.path == "/message":
agent, texte = corps.get("agent"), corps.get("texte", "").strip()
if not s:
return self._json(400, {"erreur": "pas de séance : coller un mail et Analyser"})
if agent not in ("support", "analyste") or not texte:
return self._json(400, {"erreur": "agent ou texte manquant"})
if s.occupe(agent):
return self._json(409, {"erreur": f"{agent} occupé"})
en_fond(s.parler, agent, texte)
return self._json(200, {})
self._json(404, {"erreur": self.path})
@app.get("/api/flux")
async def flux(request: Request):
"""Un message à chaque changement : les nouveaux événements et l'état de la séance. Une nouvelle séance repart de
zéro (son id change) : la page vide alors ses fils."""
async def messages():
n, id_vu, dernier, calme = 0, None, None, 0
while not await request.is_disconnected():
s = etat["seance"]
if s and s.id != id_vu:
n, id_vu = 0, s.id
m = instantane(n)
reste = {k: v for k, v in m.items() if k != "evenements"}
if m["evenements"] or reste != dernier or dernier is None:
m["depuis"] = n # 0 : tout l'historique de la séance, la page remplace ses fils au lieu d'ajouter
n, dernier, calme = m["n"], reste, 0
yield f"data: {json.dumps(m, ensure_ascii=False)}\n\n"
elif (calme := calme + 1) >= 60: # ~15 s sans rien : un commentaire garde la connexion ouverte
calme = 0
yield ": calme\n\n"
await asyncio.sleep(0.25)
return StreamingResponse(messages(), media_type="text/event-stream", headers={"Cache-Control": "no-cache"})
@app.get("/api/pdf")
def pdf():
s = etat["seance"]
v = s.derniere_version() if s else None
if not v:
return erreur(404, "pas encore de PDF")
return FileResponse(v, media_type="application/pdf", filename=f"{s.dossier.name}_{v.name}",
content_disposition_type="inline")
@app.post("/api/analyser")
def analyser(corps: dict):
s = etat["seance"]
if s and (s.occupe("support") or s.occupe("analyste")):
return erreur(409, "une séance travaille encore")
if not corps.get("mail", "").strip():
return erreur(400, "le mail est vide")
images = [(i["type"], base64.b64decode(i["base64"])) for i in corps.get("images", [])]
s = Seance(corps["mail"], images, corps.get("contexte", ""), donnees_par_defaut(), journal, client=CLIENT)
with verrou:
etat["seance"], etat["evenements"] = s, []
en_fond(s.demarrer)
return {"dossier": s.dossier.name}
@app.post("/api/message")
def message(corps: dict):
s, agent, texte = etat["seance"], corps.get("agent"), corps.get("texte", "").strip()
if not s:
return erreur(400, "pas de séance : coller un mail et Analyser")
if agent not in ("support", "analyste") or not texte:
return erreur(400, "agent ou texte manquant")
if s.occupe(agent):
return erreur(409, f"{agent} occupé")
en_fond(s.parler, agent, texte)
return {}
if PAGE.is_dir():
app.mount("/", StaticFiles(directory=PAGE, html=True), name="page")
else:
@app.get("/")
def sans_page():
return erreur(503, "la page n'est pas construite : cd API/web && npm install && npm run build")
def ouvrir(url: str) -> None:
@@ -127,8 +149,7 @@ def ouvrir(url: str) -> None:
if __name__ == "__main__":
url = f"http://127.0.0.1:{PORT}"
serveur = ThreadingHTTPServer(("127.0.0.1", PORT), Serveur)
print(f"Page support : {url}")
print(f"Support AIMsight : {url}")
if "--sans-navigateur" not in sys.argv:
ouvrir(url)
serveur.serve_forever()
threading.Timer(1, ouvrir, [url]).start()
uvicorn.run(app, host="127.0.0.1", port=PORT, log_level="warning", timeout_graceful_shutdown=1)
+14
View File
@@ -0,0 +1,14 @@
<!doctype html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Support AIMsight</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap" rel="stylesheet">
</head>
<body>
<div id="racine"></div>
<script type="module" src="/src/main.jsx"></script>
</body>
</html>
+1186
View File
File diff suppressed because it is too large. Load diff
+21
View File
@@ -0,0 +1,21 @@
{
"name": "support-aimsight",
"private": true,
"type": "module",
"scripts": {
"dev": "vite",
"build": "vite build"
},
"dependencies": {
"@mantine/core": "^9.7.5",
"@mantine/hooks": "^9.7.5",
"@mantine/notifications": "^9.7.5",
"@tabler/icons-react": "^3.50.0",
"react": "^19.3.1",
"react-dom": "^19.3.1"
},
"devDependencies": {
"@vitejs/plugin-react": "^6.2.1",
"vite": "^8.3.6"
}
}
+215
View File
@@ -0,0 +1,215 @@
import { useEffect, useRef, useState } from "react";
import {
ActionIcon, AppShell, Badge, Burger, Button, Card, Grid, Group, Image, NavLink, Paper, ScrollArea, SimpleGrid,
Stack, Text, Textarea, Title, Tooltip, useComputedColorScheme, useMantineColorScheme,
} from "@mantine/core";
import { useDisclosure } from "@mantine/hooks";
import { notifications } from "@mantine/notifications";
import { IconDownload, IconFilePlus, IconMoon, IconSend, IconSun } from "@tabler/icons-react";
const AGENTS = ["support", "analyste"];
const NOMS = { support: "Support", analyste: "Analyste" };
async function poster(chemin, corps) {
const r = await fetch(chemin, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(corps) });
if (!r.ok) notifications.show({ color: "red", title: "Refusé", message: (await r.json()).erreur });
return r.ok;
}
// Un événement d'un agent → ce que montre son fil
function message(e) {
if (e.type === "outil") return { genre: "outil", texte: "→ " + e.texte };
if (e.type === "erreur") return { genre: "erreur", texte: e.texte };
if (e.type === "entree") {
if (e.source === "marc") return { genre: "marc", qui: "Toi", texte: e.texte.replace(/^<mail>\n?|\n?<\/mail>[\s\S]*$/g, "") };
return { genre: "relai", qui: "Demande du support", texte: e.texte };
}
return { genre: e.agent, qui: NOMS[e.agent], texte: e.texte };
}
function Etat({ occupe }) {
return <Badge variant="light" color={occupe ? "orange" : "teal"}>{occupe ? "occupé…" : "prêt"}</Badge>;
}
function Entete({ dossier, mobile, bureau, basculer }) {
const { setColorScheme } = useMantineColorScheme(), schema = useComputedColorScheme("light");
return (
<AppShell.Header className="entete">
<Group h="100%" px="md" justify="space-between" wrap="nowrap">
<Group gap="sm" wrap="nowrap">
<Burger opened={mobile} onClick={basculer.mobile} hiddenFrom="sm" size="sm" color="white" aria-label="Menu" />
<Burger opened={bureau} onClick={basculer.bureau} visibleFrom="sm" size="sm" color="white" aria-label="Barre latérale" />
<Text fw={700} size="lg">AIMsight</Text>
<Text size="sm" opacity={0.6}>Support</Text>
</Group>
<Group gap="sm" wrap="nowrap">
{dossier && <Text ff="monospace" size="sm" opacity={0.75} visibleFrom="sm">{dossier}</Text>}
<Tooltip label={schema === "dark" ? "Mode clair" : "Mode sombre"}>
<ActionIcon variant="subtle" color="white" size="lg" aria-label="Changer de thème"
onClick={() => setColorScheme(schema === "dark" ? "light" : "dark")}>
{schema === "dark" ? <IconSun size={20} /> : <IconMoon size={20} />}
</ActionIcon>
</Tooltip>
</Group>
</Group>
</AppShell.Header>
);
}
function Barre({ etat }) {
const c = etat.cout, dollars = v => `${(v ?? 0).toFixed(2)} $`;
return (
<AppShell.Navbar p="xs">
<ScrollArea type="scroll">
<Text size="xs" fw={700} tt="uppercase" c="dimmed" px="sm" pt="sm" pb="xs">Séance</Text>
<NavLink active label="Nouvelle séance" leftSection={<IconFilePlus size={18} />} />
{AGENTS.map(a => <NavLink key={a} label={NOMS[a]} rightSection={<Etat occupe={etat.occupe[a]} />} />)}
<Text size="xs" fw={700} tt="uppercase" c="dimmed" px="sm" pt="lg" pb="xs">Coût</Text>
{AGENTS.map(a => <NavLink key={a} label={NOMS[a]} rightSection={<Text size="sm">{dollars(c?.[a])}</Text>} />)}
<NavLink label={<b>Total</b>} rightSection={<Text size="sm" fw={700}>{dollars(c?.total)}</Text>} />
</ScrollArea>
</AppShell.Navbar>
);
}
function Carte({ surtitre, titre, action, children, ...reste }) {
return (
<Card shadow="sm" padding={0} withBorder {...reste}>
<Group px="lg" py="md" justify="space-between" wrap="nowrap" style={{ borderBottom: "1px solid var(--mantine-color-default-border)" }}>
<div>
<Text size="xs" fw={700} tt="uppercase" c="dimmed">{surtitre}</Text>
<Text fw={500}>{titre}</Text>
</div>
{action}
</Group>
{children}
</Card>
);
}
function Saisie({ occupe }) {
const [mail, setMail] = useState(""), [contexte, setContexte] = useState(""), [images, setImages] = useState([]);
function coller(ev) {
for (const item of ev.clipboardData.items) {
if (!item.type.startsWith("image/")) continue;
const lecteur = new FileReader();
lecteur.onload = () => setImages(im => [...im, { type: item.type, url: lecteur.result, base64: lecteur.result.split(",")[1] }]);
lecteur.readAsDataURL(item.getAsFile());
}
}
async function analyser() {
if (!mail.trim()) return notifications.show({ color: "orange", message: "Colle d'abord le mail du client." });
const envoi = images.map(({ type, base64 }, i) => ({ nom: `capture-${i + 1}`, type, base64 }));
if (await poster("/api/analyser", { mail, contexte, images: envoi })) setImages([]); // pas de captures d'un client à l'autre
}
return (
<Carte surtitre="Demande" titre="Le mail du client" action={<Button onClick={analyser} disabled={occupe}>Analyser</Button>}>
<Grid p="lg" gutter="lg">
<Grid.Col span={{ base: 12, md: 8 }}>
<Textarea label="Mail du client" description="Le texte ; colle les captures ici, elles s'ajoutent en vignettes"
placeholder="Bonjour, …" autosize minRows={6} maxRows={16} value={mail}
onChange={e => setMail(e.currentTarget.value)} onPaste={coller} />
{images.length > 0 && (
<Group gap="xs" mt="xs">{images.map((im, i) => <Image key={i} src={im.url} h={52} w="auto" radius="sm" alt={`Capture ${i + 1}`} />)}</Group>
)}
</Grid.Col>
<Grid.Col span={{ base: 12, md: 4 }}>
<Textarea label="Ton contexte" description="Station, plage, ce que tu sais du cas" autosize minRows={6} maxRows={16}
value={contexte} onChange={e => setContexte(e.currentTarget.value)} />
</Grid.Col>
</Grid>
</Carte>
);
}
function Fil({ agent, evenements, occupe, seance }) {
const [texte, setTexte] = useState(""), vue = useRef(null);
useEffect(() => { vue.current?.scrollTo({ top: vue.current.scrollHeight, behavior: "smooth" }); }, [evenements.length]);
async function envoyer() {
if (texte.trim() && await poster("/api/message", { agent, texte })) setTexte("");
}
return (
<Carte surtitre={agent === "support" ? "Pilote la séance" : "Diagnostic"} titre={NOMS[agent]} action={<Etat occupe={occupe} />}
h="62vh" style={{ display: "flex", flexDirection: "column" }}>
<ScrollArea flex={1} viewportRef={vue} type="scroll">
<Stack gap="xs" p="lg">
{evenements.map((e, i) => {
const m = message(e);
if (m.genre === "outil") return <Text key={i} size="xs" c="dimmed" ff="monospace" style={{ overflowWrap: "anywhere" }}>{m.texte}</Text>;
if (m.genre === "erreur") return <Paper key={i} p="xs" bg="var(--mantine-color-red-light)" c="red"><Text size="sm">Erreur : {m.texte}</Text></Paper>;
return (
<Paper key={i} px="md" py="xs" className={`message ${m.genre}`}>
<Text size="xs" fw={700} tt="uppercase" c="dimmed">{m.qui}</Text>
<Text size="sm">{m.texte}</Text>
</Paper>
);
})}
</Stack>
</ScrollArea>
<Group gap="sm" px="lg" py="md" wrap="nowrap" align="flex-end" style={{ borderTop: "1px solid var(--mantine-color-default-border)" }}>
<Textarea flex={1} autosize minRows={1} maxRows={6} placeholder={agent === "support" ? "Au support…" : "À l'analyste…"}
value={texte} onChange={e => setTexte(e.currentTarget.value)} disabled={occupe} />
<Tooltip label="Envoyer">
<ActionIcon size="input-sm" onClick={envoyer} disabled={occupe || !seance} aria-label="Envoyer"><IconSend size={18} /></ActionIcon>
</Tooltip>
</Group>
</Carte>
);
}
function Rapport({ version, dossier }) {
const src = `/api/pdf?v=${version}`;
return (
<Carte surtitre="Rapport" titre={version ? `Version ${version.replace(".pdf", "").slice(1)}` : "Pas encore de PDF"}
action={version && <Button component="a" href={src} download={`${dossier}_${version}`} variant="light"
leftSection={<IconDownload size={16} />}>Télécharger</Button>}>
{version ? <iframe key={version} className="rapport" src={src} title="Rapport" />
: <Text c="dimmed" ta="center" p="xl">Le PDF s'affiche ici dès que le support l'a compilé.</Text>}
</Carte>
);
}
export default function App() {
const [etat, setEtat] = useState({ occupe: { support: false, analyste: false } });
const [evenements, setEvenements] = useState([]);
const [mobile, { toggle: basculerMobile }] = useDisclosure(false);
const [bureau, { toggle: basculerBureau }] = useDisclosure(true);
useEffect(() => {
const flux = new EventSource("/api/flux");
flux.onmessage = ev => {
const r = JSON.parse(ev.data), nouveaux = r.evenements.filter(e => e.type !== "cout");
// depuis = 0 : tout l'historique de la séance (nouvelle séance, ou reconnexion) ; sinon la suite
setEvenements(evs => (r.depuis === 0 ? nouveaux : [...evs, ...nouveaux]));
setEtat(r);
};
return () => flux.close();
}, []);
return (
<AppShell header={{ height: 64 }} padding="lg"
navbar={{ width: 260, breakpoint: "sm", collapsed: { mobile: !mobile, desktop: !bureau } }}>
<Entete dossier={etat.dossier} mobile={mobile} bureau={bureau} basculer={{ mobile: basculerMobile, bureau: basculerBureau }} />
<Barre etat={etat} />
<AppShell.Main bg="var(--mantine-color-default-hover)">
<Stack gap="lg">
<div>
<Title order={2}>Support</Title>
<Text c="dimmed">Colle le mail du client et ton contexte, puis Analyser ; parle au support ou à l'analyste dans leur fil.</Text>
</div>
<Saisie occupe={etat.occupe.support || etat.occupe.analyste} />
<SimpleGrid cols={{ base: 1, md: 2 }} spacing="lg">
{AGENTS.map(a => <Fil key={a} agent={a} occupe={etat.occupe[a]} seance={etat.dossier}
evenements={evenements.filter(e => e.agent === a)} />)}
</SimpleGrid>
<Rapport version={etat.version} dossier={etat.dossier} />
</Stack>
</AppShell.Main>
</AppShell>
);
}
+24
View File
@@ -0,0 +1,24 @@
import { createRoot } from "react-dom/client";
import { MantineProvider, createTheme } from "@mantine/core";
import { Notifications } from "@mantine/notifications";
import "@mantine/core/styles.css";
import "@mantine/notifications/styles.css";
import "./style.css";
import App from "./App.jsx";
// Bleu primaire #5383ff (shade 5), la palette retenue pour la page
const theme = createTheme({
primaryColor: "aimsight",
primaryShade: 5,
colors: { aimsight: ["#eef3ff", "#dce5ff", "#b8c9ff", "#91abff", "#6f92ff", "#5383ff", "#4574f5", "#3863dc", "#2c55c4", "#1d45ab"] },
fontFamily: "Roboto, Helvetica, Arial, sans-serif",
headings: { fontFamily: "Roboto, Helvetica, Arial, sans-serif" },
defaultRadius: "md",
});
createRoot(document.getElementById("racine")).render(
<MantineProvider theme={theme} defaultColorScheme="auto">
<Notifications position="top-right" />
<App />
</MantineProvider>,
);
+8
View File
@@ -0,0 +1,8 @@
/* Le reste du visuel vient de Mantine (thème dans main.jsx) */
.entete { background: #3d4977; color: #fff; border-bottom: 0; }
.message { white-space: pre-wrap; overflow-wrap: anywhere; }
.message.support, .message.relai { background: var(--mantine-color-aimsight-light); }
.message.analyste { background: var(--mantine-color-teal-light); }
.message.marc { background: var(--mantine-color-yellow-light); align-self: flex-end; max-width: 85%; }
.message.relai { border-left: 3px solid var(--mantine-color-aimsight-filled); }
.rapport { width: 100%; height: 78vh; border: 0; display: block; background: #fff; }
+8
View File
@@ -0,0 +1,8 @@
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
// npm run dev : la page sur http://localhost:5173, l'API demandée au serveur Python (port 8770)
export default defineConfig({
plugins: [react()],
server: { proxy: { "/api": "http://127.0.0.1:8770" } },
});
+1 -1
View File
@@ -14,7 +14,7 @@ Cadrage du product owner : sous-projet G, santé des sites et notifications au c
- **Maquettes du site** (D-022, D-039) : client « System Summary », une page par station, un bloc par domaine ; support « Home », une notification par station et par domaine Orange ou Red, liée à la vue client (D-025).
- **Déplacements, le cap actuel : le journal du matin** (D-056). Une anomalie de déplacement est ce qui rend les courbes non plates : presque toujours un moment où il ne faut pas se fier aux données (pluie, buée, train, toile d'araignée, turbulence…), parfois un vrai mouvement (E-004, incident de Barcelone). Détecteurs élémentaires classés par catégorie (D-074), onglet `Journal` de la maquette Explore, amélioration par `/events-learner` (D-057), base d'events `events/` revue par `/review-event` (D-075). Les détecteurs s'alignent sur toutes les étiquettes de `labeling/auto/`, sans events (D-118) : l'`etiqueteur` étiquette en amont, puis `/detector-learner <FAMILLE>` (D-116, D-132) : une famille sur toutes les stations, le `detectors-critic` juge les détecteurs face aux étiquettes, le `detectors-upgrader` les adapte, le `detectors-control` garde toutes les stations et familles ; l'analyste, le `tool-builder` et l'`event-builder` (D-088 à D-092, D-097) sont hors de la séance ; la carte des événements apprend de chaque event validé (D-087). Tout le suivi est dans le plan vivant `docs/superpowers/plans/2026-10-23-journal-du-matin.md`.
- **Support** (D-079, D-113) : `/support <mail>` répond à la question d'un client, et à elle seule (premier cas : LENZSPITZE, nuit du 26 au 27.10) ; `/support <STATION>` fait le rapport de situation de la station à partir de ses étiquettes (`labeling/auto/`), appuyé d'images ; `/presentation <STATION>` le met en diapositives PDF à la charte AIMsight, par la fabrique Typst `~/docfactory-presentation` (D-114). Rapports par mois.
- **Support par l'API Claude** (D-133), le passage à l'opérationnel : sous-projet autonome `API/`, séparé de `.claude/` ; une page `support`, deux clients API (support, analyste), un PDF qui répond au mail du client ; workflow validé par l'utilisateur le 2026-11-05 sur un premier cas réel (Crissier, LENZSPITZE, `API/cases/`) ; la copie des détecteurs à rafraîchir après leur optimisation. Préalable : les détecteurs lisent la caméra et les métriques (point 78 du plan vivant).
- **Support par l'API Claude** (D-133), le passage à l'opérationnel : sous-projet autonome `API/`, séparé de `.claude/` ; une web app `support` (React et FastAPI, D-137), deux clients API (support, analyste), un PDF qui répond au mail du client ; workflow validé par l'utilisateur le 2026-11-05 sur un premier cas réel (Crissier, LENZSPITZE, `API/cases/`) ; la copie des détecteurs à rafraîchir après leur optimisation. Préalable : les détecteurs lisent la caméra et les métriques (point 78 du plan vivant).
- **Agent de diagnostic** (D-046, D-058, D-082) : gardé dans le doute, pour un cas que les détecteurs n'expliquent pas.
- **En attente** : agents LLM côté serveur (D-027) et enquête par API (D-042), documents seulement ; communication avec la caméra (dev container, D-038), en attente de la doc de l'API REST ; détection des sauts et tendances (D-055, onglet `Displacements`), très expérimentale.
- **Prochaine étape** :
+7
View File
@@ -1264,3 +1264,10 @@ Règles du journal :
- **Pourquoi** : l'analyste recevait 214 000 caractères (~55 000 jetons) à chaque appel, la carte des étiquettes surtout, pour 1,50 $ par séance ; il n'en lit qu'une petite partie par cas. Avec les cartes, 39 000 caractères ; un essai a trouvé seul la bonne fiche par le sommaire. « Il ne faut donner que le strict nécessaire aux agents » (l'utilisateur, 2026-11-05).
- **Options écartées** : tout dans le prompt (coût, et un savoir noyé) ; une recherche par mots-clés (le sommaire de la carte suffit à trouver la fiche).
- **Conséquence** : un document lu reste dans l'historique de l'agent pour la séance, payé une fois ; l'index se refait seul quand `knowledge/` change.
## D-137 — 2026-11-05 — La page support de l'API devient une web app : React et Python (FastAPI)
- **Statut** : active. Complète D-133.
- **Décision** : la page support de `API/` est refaite en web app, aux mêmes fonctions : un front React (Vite, JavaScript) dans `API/web/`, ses composants pris à la bibliothèque open source Mantine (MIT), un serveur FastAPI (`API/support/serveur.py`) qui sert la page construite (`API/web/dist`) et l'API sous `/api` ; les événements des agents sont poussés à la page (`/api/flux`, server-sent events) au lieu d'être interrogés chaque seconde. Les agents, leurs outils, les prompts et le savoir restent tels quels. Outil interne, local d'abord ; le dossier des données, celui des séances et le port se règlent par variables (`AIMSIGHT_DATA`, `AIMSIGHT_CASES`, `AIMSIGHT_PORT`) pour un déploiement futur. Pas de PostgreSQL, d'historique des séances, d'authentification ni de plafond de coût pour l'instant ; le pompage des données reste tel quel.
- **Pourquoi** : la page doit pouvoir grandir (historique, boîte mail, voix) et passer un jour sur un serveur (l'utilisateur, 2026-11-05).
- **Options écartées** : Spring Boot (les agents et tous leurs outils sont en Python, comme l'application de référence d'AIMsight, Flask ; il aurait fallu réécrire la boucle des agents en Java et appeler chaque outil en Python de l'extérieur) ; PostgreSQL dès maintenant (il viendra avec l'historique des séances, « faisons au plus simple », l'utilisateur) ; reprendre un template d'administration (Carolina, UiFort : React 16 et Material-UI 4, trop vieux pour React 19, « on ne veut pas reprendre ses éléments », l'utilisateur) ; recoder les composants à la main (Mantine donne d'office la barre repliable, le tiroir mobile, les transitions et le mode sombre).
- **Conséquence** : `npm run build` dans `API/web/` avant de lancer le serveur ; `npm run dev` pour travailler sur la page (port 5173, l'API demandée au serveur Python).
+1 -1
View File
@@ -185,7 +185,7 @@ Faire ou refaire la présentation avec l'agent : `/presentation <STATION>` (`.cl
## La page support par l'API Claude (D-133)
Sous-projet `API/` (sa doc : `API/README.md`). Une fois : `python3 -m venv API/.venv && API/.venv/bin/pip install -r API/requirements.txt`, et les clés dans `API/.env` (`ANTHROPIC_API_KEY`, `LANGSMITH_API_KEY`, `LANGSMITH_TRACING=true`, `LANGSMITH_PROJECT=Support`). Puis :
Sous-projet `API/` (sa doc : `API/README.md`). Une fois : `python3 -m venv API/.venv && API/.venv/bin/pip install -r API/requirements.txt`, et les clés dans `API/.env` (`ANTHROPIC_API_KEY`, `LANGSMITH_API_KEY`, `LANGSMITH_TRACING=true`, `LANGSMITH_PROJECT=Support`), et la page React construite : `cd API/web && npm install && npm run build` (à refaire quand la page change, D-137). Puis :
```bash
API/.venv/bin/python API/support/serveur.py