Files
aimsight-app/app/serveur/analyse.py
T

290 lines
16 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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/<STATION>_<début>_<fin>/ 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/<STATION>.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 <analyse>` (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/<séance>_<analyse>/bilan.md) et celui des outils (<analyse>/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, <séance>_<analyse>/
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/<STATION>.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"<!doctype html><meta charset=utf-8><title>{html.escape(titre)}</title><style>{STYLE}</style>"
f"<body class='{'sombre' if sombre else ''}'>{corps}</body>")
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 <analyse>, 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")) # <séance> 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 (<analyse>/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)