2026-11-13 11:51:16 +01:00
"""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
2026-11-13 11:32:43 +01:00
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
2026-11-13 11:51:16 +01:00
(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.
2026-11-13 13:10:33 +01:00
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
2026-11-13 11:51:16 +01:00
les scripts de l'analyste dans les outils de lecture ; une optimisation à la fois, ni analyse ni message pendant ; le bilan de
2026-11-13 13:10:33 +01:00
la séance (<analyse>/detectors/<heure>/summary.md) et celui des outils (<analyse>/outils.md) s'affichent sous
2026-11-13 11:51:16 +01:00
le rapport.
2026-11-13 11:32:43 +01:00
"""
import html
import json
import os
import subprocess
import threading
2026-11-13 13:10:33 +01:00
from datetime import date , datetime , timedelta , timezone
2026-11-13 11:32:43 +01:00
import markdown
import station
DOSSIER = station . ETIQUETTES / "auto" / "analyses"
2026-11-13 13:10:33 +01:00
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, \
2026-11-13 17:10:19 +01:00
detectors/ is a link to the detectors repository, shared with Optimizer; read-only on {donnees} / and {etiquettes} /; commit only in detectors/, on its current branch; \
2026-11-13 16:27:59 +01:00
OUT is in the labeling repository (labeling/ is a link to it): do not commit it."""
2026-11-13 11:51:16 +01:00
DEMANDE = """Station : data/ {station} /. Plage : {debut} → {fin} (UTC). Indices de l'utilisateur : {indices} . \
Dossier de sortie : {sortie} /."""
2026-11-13 11:32:43 +01:00
# 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" )
2026-11-13 11:51:16 +01:00
prompt = DEMANDE . format ( station = st , debut = debut , fin = fin , sortie = sortie . relative_to ( station . RACINE ),
2026-11-13 11:32:43 +01:00
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 :
2026-11-13 11:51:16 +01:00
p = subprocess . Popen ([ "claude" , "-p" , prompt , "--agent" , "analyste" , "--output-format" , "stream-json" , "--verbose" ,
2026-11-13 16:27:59 +01:00
"--allowedTools" , "Read,Write,Bash" , "--permission-mode" , "acceptEdits" , * station . liens ()]
2026-11-13 11:32:43 +01:00
+ ([ "--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}"""
2026-11-13 11:51:16 +01:00
def _page ( texte , titre , sombre ):
2026-11-13 11:32:43 +01:00
"""Un markdown en HTML, au style de la page ; ses images relatives se résolvent dans le dossier de l'adresse."""
2026-11-13 11:51:16 +01:00
corps = markdown . markdown ( texte , extensions = [ "tables" , "fenced_code" ])
2026-11-13 11:32:43 +01:00
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."""
2026-11-13 11:51:16 +01:00
return _page ( fichier ( nom , "rapport.md" ) . read_text ( encoding = "utf-8" ), nom , sombre )
2026-11-13 11:32:43 +01:00
2026-11-13 13:10:33 +01:00
# --- « Optimiser » : /detectors:wf-improve sur l'analyse, puis le tool-builder, par claude -p
2026-11-13 11:32:43 +01:00
def _bilan ( nom ):
"""Le bilan de la dernière séance de cette analyse, ou None."""
2026-11-13 13:10:33 +01:00
bilans = sorted (( DOSSIER / nom / "detectors" ) . glob ( "*/summary.md" )) # <heure>/ : l'ordre du nom est celui du temps
2026-11-13 11:32:43 +01:00
return bilans [ - 1 ] if bilans else None
def optimisation ( nom ):
2026-11-13 11:51:16 +01:00
"""-> 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)."""
2026-11-13 11:32:43 +01:00
flux , b = DOSSIER / nom / "travail" / "optimisation.jsonl" , _bilan ( nom )
o = optimisations . get ( nom )
if o is None :
if not flux . exists ():
2026-11-13 11:51:16 +01:00
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 )]}
2026-11-13 11:32:43 +01:00
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" )
2026-11-13 13:10:33 +01:00
if not ( DETECTEURS / ".claude-plugin" / "plugin.json" ) . exists ():
2026-11-13 17:10:19 +01:00
raise station . Refus ( "pas de dépôt detectors en detectors/ (le lien : ln -s ~/detectors detectors)" )
2026-11-13 11:32:43 +01:00
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 ):
2026-11-13 11:51:16 +01:00
"""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 :
2026-11-13 13:10:33 +01:00
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 } " )
2026-11-13 17:10:19 +01:00
tours = [[ requete , "--plugin-dir" , "detectors" , "--add-dir" , str ( DETECTEURS . resolve ()), # la cible du lien, où la séance écrit
2026-11-13 13:10:33 +01:00
"--allowedTools" , "Read,Write,Edit,Bash,Agent" ],
[ f "Analyse : { rel } /. Écris { rel } /outils.md." , "--agent" , "tool-builder" , "--allowedTools" , "Read,Write,Edit,Bash" ]]
2026-11-13 11:51:16 +01:00
for prompt , * options in tours :
p = subprocess . Popen ([ "claude" , "-p" , prompt , "--output-format" , "stream-json" , "--verbose" ,
2026-11-13 16:27:59 +01:00
"--permission-mode" , "acceptEdits" , * station . liens (), * options ],
2026-11-13 11:51:16 +01:00
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
2026-11-13 11:32:43 +01:00
def bilan ( nom , sombre ):
2026-11-13 11:51:16 +01:00
"""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 ():
2026-11-13 11:32:43 +01:00
raise station . Refus ( "aucun bilan pour cette analyse" )
2026-11-13 11:51:16 +01:00
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 )