L'app ne résout plus les liens (les agents voient data/ et labeling/) et donne leur cible à claude -p par --add-dir. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
301 lines
17 KiB
Python
301 lines
17 KiB
Python
"""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:wf-improve` (le plugin du dépôt detectors, monté en detectors/) sur
|
||
la plage de l'analyse, ses étiquettes pour vérité, qui améliore les détecteurs, 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 (<analyse>/detectors/<heure>/summary.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 date, datetime, timedelta, timezone
|
||
|
||
import markdown
|
||
|
||
import station
|
||
|
||
DOSSIER = station.ETIQUETTES / "auto" / "analyses"
|
||
DETECTEURS = station.RACINE / "detectors"
|
||
# la requête de /detectors:wf-improve (detectors/README.md) : tout ce qu'il lit et écrit est donné ici, avec ses règles git
|
||
AMELIORER = """/detectors:wf-improve DETECTORS: detectors/. STATION: {donnees}/{station}. FROM: {du}. TO: {au}. \
|
||
LABELS: {etiquettes}/auto/{station}.jsonl. REFERENCE: --labels {etiquettes}/auto --data {donnees}. \
|
||
FAMILIES: {etiquettes}/familles.md. CONTEXT: {analyse}/rapport.md. OUT: {sortie}/. Caller's context: Diagnostic-app, \
|
||
the detectors/ submodule; read-only on {donnees}/ and {etiquettes}/; commit only in detectors/, on its current branch; \
|
||
OUT is in the labeling repository (labeling/ is a link to it): do not commit it."""
|
||
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", *station.liens()]
|
||
+ (["--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:wf-improve sur l'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((DOSSIER / nom / "detectors").glob("*/summary.md")) # <heure>/ : 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 (DETECTEURS / ".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)
|
||
(sortie / "travail").mkdir(exist_ok=True)
|
||
with open(sortie / "travail" / "optimisation.jsonl", "a", encoding="utf-8") as flux:
|
||
try:
|
||
d = json.loads((sortie / "demande.json").read_text(encoding="utf-8"))
|
||
requete = AMELIORER.format( # TO exclu : le jour après la fin de la plage, comme la page
|
||
station=d["station"], du=d["debut"][:10], au=date.fromisoformat(d["fin"][:10]) + timedelta(days=1),
|
||
donnees=os.path.relpath(station.DONNEES, station.RACINE), etiquettes=os.path.relpath(station.ETIQUETTES, station.RACINE),
|
||
analyse=rel, sortie=f"{rel}/detectors/{datetime.now(timezone.utc):%Y%m%dT%H%MZ}")
|
||
tours = [[requete, "--plugin-dir", "detectors",
|
||
"--allowedTools", "Read,Write,Edit,Bash,Agent"],
|
||
[f"Analyse : {rel}/. Écris {rel}/outils.md.", "--agent", "tool-builder", "--allowedTools", "Read,Write,Edit,Bash"]]
|
||
for prompt, *options in tours:
|
||
p = subprocess.Popen(["claude", "-p", prompt, "--output-format", "stream-json", "--verbose",
|
||
"--permission-mode", "acceptEdits", *station.liens(), *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)
|