"""L'onglet Analysis de la page Data : un analyste (l'étiqueteur, .claude/agents/etiqueteur.md) lancé par `claude -p`, non interactif, sur une plage choisie dans la page, avec les indices facultatifs de l'utilisateur. Il écrit dans labeling/auto/analyses/__/ ses étiquettes (etiquettes.jsonl) et un rapport de diagnostic (rapport.md, ses figures à côté) ; à la fin, le serveur verse ses étiquettes dans labeling/auto/.jsonl, marquées de leur analyse (champ `analyse`, sans `revue` : à relire par /review-auto-labels). Puis l'utilisateur peut lui écrire : la même session reprend (`claude -p --resume`), et ses étiquettes, si elles changent, remplacent celles qu'il avait versées. Sur une analyse finie, « Optimiser » lance `/detector-learner ` par `claude -p` (D-148) : les détecteurs, puis les outils de lecture, améliorés depuis l'analyse ; une optimisation à la fois, ni analyse ni message pendant ; son bilan, detector-learner/_/bilan.md, s'affiche sous le rapport. """ import html import json import os import subprocess import threading from datetime import datetime, timezone import markdown import station DOSSIER = station.ETIQUETTES / "auto" / "analyses" SEANCES = station.RACINE / "detector-learner" # les séances de /detector-learner, _/ CONSIGNE = """Tu travailles pour la page Data de la web app : l'utilisateur a sélectionné une plage et te demande de la \ diagnostiquer. Ce n'est pas un lot ordinaire : il y a vu une anomalie que les détecteurs captent mal, ou il veut une analyse \ plus poussée. - Station : data/{station}/ - Lot : {debut} → {fin} (UTC) - Dossier de sortie : {sortie}/ (tes figures de travail et les sorties des outils dans {sortie}/travail/) - Indices de l'utilisateur : {indices} Fais ton travail d'étiqueteur sur ce lot, à ces différences près : 1. Tes étiquettes vont dans {sortie}/etiquettes.jsonl ; c'est le serveur qui les versera dans labeling/auto/{station}.jsonl. \ Celles qui y sont déjà sur la plage (lis-les) restent : ne refais pas une étiquette juste ; une étiquette que tu crois fausse, \ dis-le dans le rapport. 2. En plus de {sortie}/analyse.md, écris {sortie}/rapport.md, le rapport de diagnostic que l'utilisateur lira dans la page, \ en français, comme l'analyse d'un cas du support : - `# {station} : `, puis la question (sa sélection, ses indices) en une ou deux phrases ; - « Ce que montrent les données » : chaque événement daté (UTC), les capteurs touchés et ceux qui ne bougent pas, la \ cause et son niveau de preuve (confirmed / strongly supported / consistent with / possible / insufficient evidence / not \ observed), la commande qui fonde chaque fait ; - les figures qui prouvent, chacune insérée par `![légende](chemin relatif à {sortie}/)` et suivie d'une ligne qui dit ce \ qu'on y voit : courbes (graphique.py), vignettes, images entières de la caméra (copie-les dans {sortie}/ avec cp) ; \ quelques-unes, choisies, pas toutes celles de travail ; - « Ce qui reste non établi » ; « Étiquettes » : celles que tu proposes, en une ligne chacune. Réponds en 2 lignes : le nombre d'étiquettes, le chemin du rapport.""" # nom -> {"etat": "en cours" | "fini" | "erreur", "lignes": [...], "versees": n} ; une analyse à la fois par plage analyses, verrou = {}, threading.Lock() # nom de l'analyse -> {"etat": "en cours" | "fini" | "erreur", "lignes": [...]} ; une optimisation à la fois, toutes analyses optimisations = {} OCCUPE = "une optimisation des détecteurs est en cours" def _optimise(): return any(o["etat"] == "en cours" for o in optimisations.values()) def lancer(corps): st, debut, fin = corps.get("station"), corps.get("debut"), corps.get("fin") station._valide({"description": "-"}, debut, fin) station.dossier(st) nom = f"{st}_{debut[:16].replace(':', '')}_{fin[:16].replace(':', '')}" with verrou: if _optimise(): raise station.Refus(OCCUPE) if analyses.get(nom, {}).get("etat") == "en cours": raise station.Refus("cette plage est déjà en cours d'analyse") sortie = DOSSIER / nom if sortie.exists(): # une nouvelle analyse de la même plage : l'ancienne reste, à côté nom += datetime.now(timezone.utc).strftime("_%H%M%S") sortie = DOSSIER / nom indices = (corps.get("indices") or "").strip() demande = {"station": st, "debut": debut, "fin": fin, "indices": indices} analyses[nom] = {"etat": "en cours", "lignes": [], "versees": 0, "station": st, "demande": demande} (sortie / "travail").mkdir(parents=True) (sortie / "demande.json").write_text(json.dumps(demande, ensure_ascii=False, indent=1), encoding="utf-8") prompt = CONSIGNE.format(station=st, debut=debut, fin=fin, sortie=sortie.relative_to(station.RACINE), indices=indices or "aucun") threading.Thread(target=travailler, args=(nom, sortie, prompt), daemon=True).start() return {"nom": nom} def travailler(nom, sortie, prompt, reprise=None): """Un tour de l'analyste : la demande, ou un message de l'utilisateur dans la même session (reprise : son id).""" a = analyses[nom] try: p = subprocess.Popen(["claude", "-p", prompt, "--agent", "etiqueteur", "--output-format", "stream-json", "--verbose", "--allowedTools", "Read,Write,Bash", "--permission-mode", "acceptEdits"] + (["--resume", reprise] if reprise else []), cwd=station.RACINE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True) with open(sortie / "travail" / "journal.jsonl", "a", encoding="utf-8") as journal: for ligne in p.stdout: journal.write(ligne) a["lignes"] += resume(ligne) if '"subtype":"init"' in ligne: # la session, pour les messages suivants (sortie / "travail" / "session").write_text(json.loads(ligne)["session_id"]) if p.wait(): raise RuntimeError(f"claude a fini avec le code {p.returncode}") a["versees"] = verser(a["station"], nom, sortie) a["etat"] = "fini" except Exception as e: # noqa: BLE001 — l'erreur s'affiche dans la page, le serveur continue a["lignes"].append(f"Erreur : {e}") a["etat"] = "erreur" def message(nom, corps): """Un message de l'utilisateur à l'analyste, après son rapport : la même session reprend (claude -p --resume).""" texte, sortie = (corps.get("texte") or "").strip(), DOSSIER / nom etat(nom) # le nom vérifié, l'état relu après un redémarrage a, session = analyses[nom], sortie / "travail" / "session" if not texte or not session.exists(): raise station.Refus("message vide, ou l'analyse n'a pas de session à reprendre") with verrou: if _optimise(): raise station.Refus(OCCUPE) if a["etat"] == "en cours": raise station.Refus("l'analyste travaille encore") a["etat"] = "en cours" ligne = json.dumps({"type": "page", "texte": texte}, ensure_ascii=False) + "\n" with open(sortie / "travail" / "journal.jsonl", "a", encoding="utf-8") as journal: journal.write(ligne) a["lignes"] += resume(ligne) prompt = (f"{texte}\n\n(Si tu changes tes étiquettes, réécris {sortie.relative_to(station.RACINE)}/etiquettes.jsonl en " "entier, le serveur les reversera ; si le diagnostic change, mets rapport.md à jour.)") threading.Thread(target=travailler, args=(nom, sortie, prompt, session.read_text()), daemon=True).start() return {} def resume(ligne): """Une ligne du journal -> ce que la page en montre : les messages de l'utilisateur (« › »), les textes de l'analyste, ses outils et leur commande, en une ligne chacun.""" try: m = json.loads(ligne) except json.JSONDecodeError: return [ligne.strip()[:200]] if ligne.strip() else [] if m.get("type") == "page": return [f"› {m['texte']}"] if m.get("type") != "assistant": return [] out = [] for c in m["message"].get("content", []): if c.get("type") == "text" and c["text"].strip(): out.append(c["text"].strip()[:300]) elif c.get("type") == "tool_use": i = c.get("input", {}) out.append(f"{c['name']} : {i.get('command') or i.get('file_path') or ''}"[:200]) return out def verser(st, nom, sortie): """Les étiquettes de l'analyse dans labeling/auto/.jsonl, avec leur id et le nom de l'analyse ; si l'analyste les a changées depuis le dernier versement, elles remplacent celles qu'il y avait versées -> leur nombre.""" fichier, copie = sortie / "etiquettes.jsonl", sortie / "travail" / "versees.jsonl" texte = fichier.read_text(encoding="utf-8") if fichier.exists() else "" nouvelles = [] for l in texte.split("\n"): if l.strip(): e = json.loads(l) station._valide(e, e.get("debut"), e.get("fin")) nouvelles.append({k: e[k] for k in ("debut", "fin", "categorie", "description") if k in e} | {"analyse": nom}) if copie.exists() and copie.read_text(encoding="utf-8") == texte: return len(nouvelles) # ponytail: retirées puis remises, les étiquettes de l'analyse perdent les retouches faites dans la page ; les garder # demanderait de les apparier une à une with verrou: f = station.fichier(st, "auto") # les autres lignes restent telles quelles gardees = [l for l in (f.read_text(encoding="utf-8").split("\n") if f.exists() else []) if l.strip() and json.loads(l).get("analyse") != nom] station.attribuer(st, [json.loads(l) for l in gardees] + nouvelles) provisoire = f.with_name(f.name + ".tmp") provisoire.write_text("".join(l + "\n" for l in gardees + [json.dumps(e, ensure_ascii=False) for e in nouvelles]), encoding="utf-8") os.replace(provisoire, f) copie.write_text(texte, encoding="utf-8") return len(nouvelles) def etat(nom): sortie = DOSSIER / nom if "/" in nom or nom.startswith(".") or not sortie.is_dir(): raise station.Refus("analyse inconnue") if nom not in analyses: # après un redémarrage du serveur, il ne reste que le dossier : le fil se relit dans le journal journal = sortie / "travail" / "journal.jsonl" lignes = [r for l in open(journal, encoding="utf-8") for r in resume(l)] if journal.exists() else [] demande = json.loads((sortie / "demande.json").read_text(encoding="utf-8")) analyses[nom] = {"etat": "fini" if (sortie / "rapport.md").exists() else "interrompue", "lignes": lignes, "versees": None, "station": demande["station"], "demande": demande} a, r = analyses[nom], sortie / "rapport.md" return {"nom": nom, "etat": a["etat"], "lignes": a["lignes"], "versees": a["versees"], "rapport": int(r.stat().st_mtime) if r.exists() else None, "dialogue": (sortie / "travail" / "session").exists(), "demande": a["demande"], "optimisation": optimisation(nom)} def liste(): """L'historique des analyses (la barre latérale), la plus récente en tête : celles du serveur avec leur état, les autres lues sur le disque (fini avec un rapport, sinon interrompue : une analyse s'arrête avec le serveur).""" out = [] for d in sorted(DOSSIER.glob("*/demande.json"), key=lambda f: f.parent.stat().st_mtime, reverse=True): nom = d.parent.name a = analyses.get(nom) or {"etat": "fini" if (d.parent / "rapport.md").exists() else "interrompue", "demande": json.loads(d.read_text(encoding="utf-8"))} out.append({"nom": nom, "etat": a["etat"]} | a["demande"]) return out def fichier(nom, chemin): """Un fichier du dossier de l'analyse (le rapport, ses figures), jamais au-dehors.""" f = (DOSSIER / nom / chemin).resolve() if not f.is_file() or not f.is_relative_to(DOSSIER.resolve()): raise station.Refus("fichier inconnu") return f STYLE = """body{font:14px/1.55 Roboto,sans-serif;margin:0;padding:4px 2px;color:#212529;background:transparent} h1{font-size:20px}h2{font-size:16px;margin-top:22px}img{max-width:100%;border:1px solid #dee2e6;border-radius:4px} code{font-size:12px;background:#f1f3f5;padding:1px 4px;border-radius:3px}pre{overflow-x:auto} table{border-collapse:collapse}td,th{border:1px solid #dee2e6;padding:3px 8px;text-align:left} body.sombre{color:#c9c9c9}body.sombre code{background:#2e2e2e}body.sombre td,body.sombre th,body.sombre img{border-color:#424242}""" def _page(chemin, titre, sombre): """Un markdown en HTML, au style de la page ; ses images relatives se résolvent dans le dossier de l'adresse.""" corps = markdown.markdown(chemin.read_text(encoding="utf-8"), extensions=["tables", "fenced_code"]) return (f"{html.escape(titre)}" f"{corps}") def rapport(nom, sombre): """rapport.md en HTML, servi dans le dossier de l'analyse : ses images relatives s'y retrouvent.""" return _page(fichier(nom, "rapport.md"), nom, sombre) # --- « Optimiser » : /detector-learner par claude -p (D-148) def _bilan(nom): """Le bilan de la dernière séance de cette analyse, ou None.""" bilans = sorted(SEANCES.glob(f"*_{nom}/bilan.md")) # en tête du nom : l'ordre du nom est celui du temps return bilans[-1] if bilans else None def optimisation(nom): """-> None (jamais optimisée) ou {etat, lignes, bilan : mtime du dernier bilan}. Après un redémarrage, l'état se relit sur le disque : fini si un bilan est plus récent que le flux, sinon interrompue.""" flux, b = DOSSIER / nom / "travail" / "optimisation.jsonl", _bilan(nom) o = optimisations.get(nom) if o is None: if not flux.exists(): return None if b is None else {"etat": "fini", "lignes": [], "bilan": int(b.stat().st_mtime)} o = {"etat": "fini" if b and b.stat().st_mtime >= flux.stat().st_mtime else "interrompue", "lignes": [r for l in open(flux, encoding="utf-8") for r in resume(l)]} optimisations[nom] = o return {"etat": o["etat"], "lignes": o["lignes"], "bilan": int(b.stat().st_mtime) if b else None} def optimiser(nom): """Le bouton « Optimiser » sur une analyse finie : la séance dans un fil ; refusée si une optimisation ou une analyse tourne.""" if etat(nom)["etat"] != "fini": raise station.Refus("seule une analyse finie s'optimise") with verrou: if _optimise(): raise station.Refus(OCCUPE) if any(a["etat"] == "en cours" for a in analyses.values()): raise station.Refus("une analyse est en cours : l'optimisation attend sa fin") optimisations[nom] = {"etat": "en cours", "lignes": []} threading.Thread(target=optimiser_fil, args=(nom,), daemon=True).start() return {} def optimiser_fil(nom): o = optimisations[nom] try: p = subprocess.Popen(["claude", "-p", f"/detector-learner {nom}", "--output-format", "stream-json", "--verbose", "--allowedTools", "Read,Write,Edit,Bash,Agent", "--permission-mode", "acceptEdits"], cwd=station.RACINE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True) (DOSSIER / nom / "travail").mkdir(exist_ok=True) with open(DOSSIER / nom / "travail" / "optimisation.jsonl", "a", encoding="utf-8") as flux: for ligne in p.stdout: flux.write(ligne) o["lignes"] += resume(ligne) if p.wait(): raise RuntimeError(f"claude a fini avec le code {p.returncode}") o["etat"] = "fini" except Exception as e: # noqa: BLE001 — l'erreur s'affiche dans la page, le serveur continue o["lignes"].append(f"Erreur : {e}") o["etat"] = "erreur" finally: station.detecteurs.cache_clear() # les détecteurs ont pu changer : la page Data les recalcule def bilan(nom, sombre): b = _bilan(nom) if b is None: raise station.Refus("aucun bilan pour cette analyse") return _page(b, nom, sombre)