"""L'onglet Analysis de la page Data : l'analyste (.claude/agents/analyste.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`). 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 `/detectors:detector-learner ` (le plugin du dépôt detectors, monté en detectors/), qui améliore les détecteurs depuis l'analyse, puis le tool-builder (.claude/agents/tool-builder.md), qui fait entrer les scripts de l'analyste dans les outils de lecture ; une optimisation à la fois, ni analyse ni message pendant ; le bilan de la séance (detectors/detector-learner/_/bilan.md) et celui des outils (/outils.md) s'affichent 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 / "detectors" / "detector-learner" # les séances de /detectors:detector-learner, _/ DEMANDE = """Station : data/{station}/. Plage : {debut} → {fin} (UTC). Indices de l'utilisateur : {indices}. \ Dossier de sortie : {sortie}/.""" # 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 = DEMANDE.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", "analyste", "--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(texte, 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(texte, 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").read_text(encoding="utf-8"), nom, sombre) # --- « Optimiser » : /detectors:detector-learner , puis le tool-builder, par claude -p 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 dans le flux : sa dernière ligne {"type": "fin"} dit fini ou erreur ; sans elle, l'optimisation a été coupée (interrompue).""" flux, b = DOSSIER / nom / "travail" / "optimisation.jsonl", _bilan(nom) o = optimisations.get(nom) if o is None: if not flux.exists(): return None lignes = flux.read_text(encoding="utf-8").splitlines() fin = json.loads(lignes[-1]) if lignes and lignes[-1].startswith('{"type": "fin"') else None o = {"etat": "interrompue" if fin is None else fin["etat"], "lignes": [r for l in lignes 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") if not (station.RACINE / "detectors" / ".claude-plugin" / "plugin.json").exists(): raise station.Refus("le dépôt detectors n'est pas monté en detectors/ (git submodule update --init)") 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): """Les deux tours de l'optimisation, l'un après l'autre : les détecteurs (le plugin detectors), puis les outils de lecture (le tool-builder, même si les détecteurs n'ont pas changé).""" o, sortie = optimisations[nom], DOSSIER / nom rel = os.path.relpath(sortie, station.RACINE) tours = [["/detectors:detector-learner " + nom, "--plugin-dir", "detectors", "--allowedTools", "Read,Write,Edit,Bash,Agent"], [f"Analyse : {rel}/. Écris {rel}/outils.md.", "--agent", "tool-builder", "--allowedTools", "Read,Write,Edit,Bash"]] (sortie / "travail").mkdir(exist_ok=True) with open(sortie / "travail" / "optimisation.jsonl", "a", encoding="utf-8") as flux: try: for prompt, *options in tours: p = subprocess.Popen(["claude", "-p", prompt, "--output-format", "stream-json", "--verbose", "--permission-mode", "acceptEdits", *options], cwd=station.RACINE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True) 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: flux.write(json.dumps({"type": "fin", "etat": o["etat"]}) + "\n") station.detecteurs.cache_clear() # les détecteurs ont pu changer : la page Data les recalcule def bilan(nom, sombre): """Le bilan de la séance des détecteurs, puis celui des outils (/outils.md), en une page.""" b, outils = _bilan(nom), DOSSIER / nom / "outils.md" if b is None and not outils.exists(): raise station.Refus("aucun bilan pour cette analyse") texte = "\n\n".join(f.read_text(encoding="utf-8") for f in (b, outils) if f and f.exists()) return _page(texte, nom, sombre)