Les 5 évolutions : plan, auto-critique, RAG, vérif HTML, benchmark

1. Plan-puis-exécute (enhance.make_plan) : les demandes complexes sont
   décomposées en 3-5 étapes (event SSE 'plan', carte PLAN dans le fil,
   meta.plan persisté) ; le plan guide l'agent et le moteur code.
2. Auto-critique « Qualité + » (enhance.self_review, toggle Intelligence) :
   critique éclair puis révision de la réponse (event 'revision').
3. Mémoire long-terme RAG (rag.py) : échanges vectorisés via /api/embed
   (modèle d'embedding auto-détecté), rappel cosinus top-3 inter-sessions
   injecté en contexte, indexation en arrière-plan, élagage à 2000 souvenirs.
4. Vérification HTML (tools.check_html) : références locales cassées et
   balises déséquilibrées ; branchée sur l'auto-vérification des outils ET
   sur le moteur code avec une passe d'auto-correction Aider.
5. Benchmark intégré (bench.py + /api/bench) : 5 épreuves notées /100
   (appel d'outil, code exécuté en sous-processus isolé, consignes, JSON,
   format), streaming SSE, scores stockés ; carte BENCHMARK dans l'UI.

Config : plan_mode / self_review / rag_enabled / embed_model + carte
Intelligence (3 toggles). Client SSE : events plan/revision ; PlanCard.

Tests : heuristique+parsing du plan, révision, index/rappel RAG (exclusion
de la session courante), html_check, bench 100/100 sur modèle simulé,
intégration chat HTTP (event plan + meta persisté), build front.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SVay7z3y7q2gEe54ByAE6N

backend/app/routes/benchmark.py

@@ -0,0 +1,35 @@
+"""Routes du benchmark de modèles."""
+from __future__ import annotations
+
+import json
+
+from fastapi import APIRouter
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from .. import bench
+
+router = APIRouter(prefix="/api/bench", tags=["bench"])
+
+
+class BenchRequest(BaseModel):
+    model: str
+
+
+@router.get("")
+async def scores() -> dict:
+    return {"scores": bench.get_scores()}
+
+
+@router.post("")
+async def run(req: BenchRequest) -> StreamingResponse:
+    async def event_stream():
+        async for ev in bench.run_bench(req.model):
+            etype = ev.pop("type")
+            yield f"event: {etype}\ndata: {json.dumps(ev, ensure_ascii=False)}\n\n"
+
+    return StreamingResponse(
+        event_stream(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache, no-transform", "X-Accel-Buffering": "no"},
+    )

backend/app/routes/chat.py

@@ -18,7 +18,8 @@ from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
-from .. import agent_config, coder, db, memory, router as msg_router
+from .. import agent_config, coder, db, enhance, memory, rag, router as msg_router
+from ..tools import check_html, _safe_path
 from ..agent import run_agent
 from ..config import settings
 
@@ -36,33 +37,92 @@ def _sse(event: str, data: dict) -> str:
     return f"event: {event}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"
 
 
-async def _code_stream(req: ChatRequest, model: str):
-    """Chemin « moteur code » : Aider travaille, on garde le flux SSE vivant."""
-    instruction = req.content
-    yield _sse("tool_call", {"name": "code_task", "args": {"instruction": instruction}})
-
+async def _run_aider_keepalive(instruction: str, model: str):
+    """Lance Aider dans un thread en gardant le flux SSE vivant."""
     task = asyncio.create_task(
         asyncio.to_thread(coder.run_code_task, instruction, model, None)
     )
-    # Keepalive SSE pendant le travail (peut durer plusieurs minutes).
     while not task.done():
         await asyncio.sleep(10)
         if not task.done():
+            yield None  # signal keepalive
+    yield await task
+
+
+async def _code_stream(
+    req: ChatRequest, model: str, *, extra: str = "", plan: list[str] | None = None
+):
+    """Chemin « moteur code » : Aider + vérification HTML avec auto-correction."""
+    instruction = req.content + (extra or "")
+    yield _sse("tool_call", {"name": "code_task", "args": {"instruction": req.content}})
+
+    result = None
+    async for item in _run_aider_keepalive(instruction, model):
+        if item is None:
             yield ": keepalive\n\n"
-    result = await task
+        else:
+            result = item
 
     status = "ok" if result.get("ok") else "error"
     record = {
         "name": "code_task",
-        "args": {"instruction": instruction},
+        "args": {"instruction": req.content},
         "summary": result.get("summary", "terminé"),
         "status": status,
     }
     tools_meta = [record]
     yield _sse("tool_result", record)
 
+    all_files = list(result.get("files") or [])
+
+    # Vérification des pages HTML produites + une passe d'auto-correction.
+    html_issues: list[str] = []
+    for f in all_files:
+        if f.lower().endswith((".html", ".htm")):
+            try:
+                issues = check_html(_safe_path(f))
+            except Exception:
+                issues = []
+            if issues:
+                html_issues.append(f"{f} : " + " ; ".join(issues))
+
+    if html_issues and result.get("ok"):
+        yield _sse("tool_call", {"name": "html_check", "args": {"path": "vérification"}})
+        yield _sse("tool_result", {
+            "name": "html_check", "args": {"path": "vérification"},
+            "summary": " | ".join(html_issues)[:200], "status": "error",
+        })
+        tools_meta.append({
+            "name": "html_check", "args": {},
+            "summary": " | ".join(html_issues)[:200], "status": "error",
+        })
+        fix_instruction = (
+            "Corrige ces problèmes détectés dans les fichiers HTML, sans rien "
+            "casser d'autre :\n" + "\n".join(html_issues)
+        )
+        fix = None
+        async for item in _run_aider_keepalive(fix_instruction, model):
+            if item is None:
+                yield ": keepalive\n\n"
+            else:
+                fix = item
+        fix_rec = {
+            "name": "code_task",
+            "args": {"instruction": "auto-correction HTML"},
+            "summary": fix.get("summary", "terminé"),
+            "status": "ok" if fix.get("ok") else "error",
+        }
+        tools_meta.append(fix_rec)
+        yield _sse("tool_call", {"name": "code_task", "args": fix_rec["args"]})
+        yield _sse("tool_result", fix_rec)
+        for f in fix.get("files") or []:
+            if f not in all_files:
+                all_files.append(f)
+        if fix.get("text"):
+            result["text"] = (result.get("text") or "") + "\n\n" + fix["text"]
+
     # Cartes par fichier modifié (réutilise le rendu write_file de l'UI).
-    for f in result.get("files") or []:
+    for f in all_files:
         file_rec = {
             "name": "write_file",
             "args": {"path": f},
@@ -79,10 +139,10 @@ async def _code_stream(req: ChatRequest, model: str):
     if text:
         yield _sse("token", {"content": text})
 
-    db.add_message(
-        req.session_id, "assistant", text, model,
-        meta={"tools": tools_meta, "engine": "code"},
-    )
+    meta: dict = {"tools": tools_meta, "engine": "code"}
+    if plan:
+        meta["plan"] = plan
+    db.add_message(req.session_id, "assistant", text, model, meta=meta)
     yield _sse("done", {"content": text, "tools": tools_meta})
 
 
@@ -113,22 +173,61 @@ async def chat(req: ChatRequest) -> StreamingResponse:
     # Mémoire compressée : système + résumé des anciens tours + messages récents.
     convo = memory.build_convo(req.session_id, cfg["system_prompt"])
 
+    # Mémoire long-terme (RAG) : souvenirs pertinents des autres sessions.
+    if cfg.get("rag_enabled", True):
+        memories = await rag.recall(
+            req.session_id, req.content, embed_model=cfg.get("embed_model")
+        )
+        if memories:
+            convo.insert(1, {
+                "role": "system",
+                "content": "Souvenirs pertinents d'anciennes sessions :\n"
+                + "\n---\n".join(memories),
+            })
+
     # Moteur code : choisit le meilleur modèle code installé (config "auto").
     code_model = (
         await coder.pick_code_model(model, cfg.get("code_model"))
         if use_code else model
     )
 
+    # Plan-puis-exécute : les demandes complexes sont décomposées d'abord.
+    plan: list[str] = []
+    if cfg.get("plan_mode", True) and (use_code or enhance.needs_plan(req.content)):
+        plan = await enhance.make_plan(model, req.content)
+
     async def event_stream():
         yield _sse("start", {"model": model, "engine": "code" if use_code else "agent"})
 
+        if plan:
+            yield _sse("plan", {"steps": plan})
+
         # Chemin « moteur code » : Aider gère la tâche de bout en bout.
         if use_code:
-            async for chunk in _code_stream(req, code_model):
+            instruction_plan = (
+                "\n\nPlan à suivre :\n"
+                + "\n".join(f"{i+1}. {s}" for i, s in enumerate(plan))
+                if plan else ""
+            )
+            async for chunk in _code_stream(req, code_model, extra=instruction_plan, plan=plan):
                 yield chunk
             asyncio.create_task(memory.maybe_summarize(req.session_id, model))
+            if cfg.get("rag_enabled", True):
+                last = db.list_messages(req.session_id)
+                answer = last[-1]["content"] if last else ""
+                asyncio.create_task(rag.index_exchange(
+                    req.session_id, req.content, answer,
+                    embed_model=cfg.get("embed_model"),
+                ))
             return
 
+        if plan:
+            convo.append({
+                "role": "system",
+                "content": "Plan à suivre pour cette demande :\n"
+                + "\n".join(f"{i+1}. {s}" for i, s in enumerate(plan)),
+            })
+
         final_content = ""
         tools_meta: list[dict] = []
         stats_meta: dict | None = None
@@ -198,6 +297,20 @@ async def chat(req: ChatRequest) -> StreamingResponse:
             with suppress(asyncio.CancelledError):
                 await producer
 
+        # Auto-critique : relecture éclair puis révision (option « Qualité + »).
+        if (
+            cfg.get("self_review", False)
+            and final_content
+            and not error_message
+            and not tools_meta
+        ):
+            yield _sse("status", {"message": "Relecture de la réponse…"})
+            revised = await enhance.self_review(model, req.content, final_content)
+            if revised:
+                final_content = revised
+                yield _sse("revision", {"content": revised})
+                yield _sse("notice", {"message": "Réponse révisée après auto-critique ✓"})
+
         if final_content or tools_meta:
             meta: dict = {}
             if tools_meta:
@@ -206,6 +319,8 @@ async def chat(req: ChatRequest) -> StreamingResponse:
                 meta["stats"] = stats_meta
             if thinking_meta:
                 meta["thinking"] = thinking_meta
+            if plan:
+                meta["plan"] = plan
             db.add_message(
                 req.session_id,
                 "assistant",
@@ -222,8 +337,13 @@ async def chat(req: ChatRequest) -> StreamingResponse:
                 "error": error_message or None,
             },
         )
-        # Compression de l'historique en arrière-plan (sans bloquer la réponse).
+        # Tâches d'arrière-plan : compression de l'historique + mémoire RAG.
         asyncio.create_task(memory.maybe_summarize(req.session_id, model))
+        if cfg.get("rag_enabled", True) and final_content:
+            asyncio.create_task(rag.index_exchange(
+                req.session_id, req.content, final_content,
+                embed_model=cfg.get("embed_model"),
+            ))
 
     return StreamingResponse(
         event_stream(),

backend/app/routes/config.py

@@ -22,6 +22,10 @@ class ConfigPatch(BaseModel):
     confirm_shell: bool | None = None
     think: bool | None = None
     code_model: str | None = None
+    plan_mode: bool | None = None
+    self_review: bool | None = None
+    rag_enabled: bool | None = None
+    embed_model: str | None = None
 
 
 @router.get("")