Update main.py

main.py

@@ -1,8 +1,7 @@
-# app.py — ADN NEXUS V10.3.2 AGENTIC IDE (SECURED WS + LOGIN SCREEN + FEW-SHOT AGENT)
-# Serveur FastAPI + Client IDE embarque + Agent + Tool-calling
-#
-# requirements.txt doit inclure "pytest>=7.4.0" pour que le bouton "Tests"
-# (qui delegue a l'agent l'execution de `pytest` via run_python) fonctionne.
+# main.py — ADN NEXUS V10.3.2 AGENTIC IDE (SECURED WS + LOGIN SCREEN + FEW-SHOT AGENT)
+# Version nettoyée : plus de workers de scraping permanents, extraction à la demande uniquement
+# (Les branches git_log, api_contract, impact_analysis sont conservées car les objets sont définis)
+
 from __future__ import annotations
 
 import os
@@ -32,7 +31,7 @@ from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Depe
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse, JSONResponse
 import numpy as np
-from sentence_transformers import SentenceTransformer, CrossEncoder
+from sentence_transformers import SentenceTransformer
 import feedparser
 from bs4 import BeautifulSoup
 
@@ -43,20 +42,10 @@ from transformers import AutoModelForCausalLM, AutoTokenizer
 logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)-8s | %(message)s")
 logger = logging.getLogger("nexus_v103")
 
-# Detection materielle centralisee, calculee une seule fois au demarrage.
-# Tous les composants (modele de generation, encodeur, reranker) lisent
-# cette meme valeur plutot que de deviner chacun de leur cote — evite
-# qu'un composant charge sur GPU pendant qu'un autre reste sur CPU par
-# defaut faute de parametre explicite, et donne un log clair et unique
-# de ce qui a ete detecte.
 _DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 logger.info(f"Materiel detecte : {_DEVICE.upper()}" + (f" ({torch.cuda.get_device_name(0)})" if _DEVICE == "cuda" else " — pas de GPU disponible, bascule automatique sur CPU"))
 
-
 def _load_token(env_name: str) -> str:
-    """Charge un token depuis les secrets HF Spaces (variable d'env).
-    Si absent, genere un token aleatoire fort et l'affiche UNE FOIS dans les
-    logs au demarrage — jamais de valeur par defaut previsible en dur."""
     val = os.getenv(env_name)
     if val:
         return val
@@ -69,15 +58,12 @@ def _load_token(env_name: str) -> str:
     )
     return generated
 
-
 class Config:
     PORT = int(os.getenv("PORT", 7860))
     HF_TOKEN = os.getenv("HF_TOKEN")
     DEVICE = _DEVICE
-    # Tokens charges depuis les secrets HF Spaces — plus de valeur par defaut
-    # devinable ("nexus_secret_12345", "123456") codee en dur dans le code.
     API_TOKEN = _load_token("API_TOKEN")
-    LEGACY_TOKEN = os.getenv("LEGACY_TOKEN")  # optionnel, retro-compat uniquement si defini explicitement
+    LEGACY_TOKEN = os.getenv("LEGACY_TOKEN")
     MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-1.5B-Instruct")
     TIMEOUT = int(os.getenv("TIMEOUT", 180))
     WORKSPACE_ROOT = Path("/tmp/workspace")
@@ -87,7 +73,6 @@ class Config:
     WORKSPACE_ROOT.mkdir(parents=True, exist_ok=True)
     CACHE_TTL = 300
     QUEUE_MAXSIZE = 10000
-    NUM_SCRAPE_WORKERS = 2
     MAX_CONTENT_LENGTH = 5000
     CHUNK_SIZE = 1000
     CHUNK_OVERLAP = 200
@@ -95,30 +80,17 @@ class Config:
     RATE_LIMIT_WINDOW = 60
     MAX_TOKENS = 512
     TEMPERATURE = 0.2
-    # Raisonnement multi-candidats (optionnel, desactive par defaut) : genere
-    # plusieurs reponses avec un vrai echantillonnage stochastique (do_sample
-    # + temperature) pour la premiere etape d'une tache libre, puis choisit
-    # la meilleure par heuristique avant de poursuivre la boucle normale.
-    # Double le cout de calcul pour cette etape — a activer au cas par cas.
     SAMPLING_CANDIDATES = int(os.getenv("SAMPLING_CANDIDATES", 2))
     REASONING_TEMPERATURE = float(os.getenv("REASONING_TEMPERATURE", 0.7))
-    # Gestion de la fenetre de contexte pour les sessions longues : au-dela
-    # de ce nombre de tokens dans l'historique de la tache, les anciens
-    # resultats d'outils sont tronques (nettoyage cible deterministe, pas
-    # un resume genere par le modele — voir _compress_old_tool_results).
-    # Marge sous max_length=2048 utilise dans generate() pour laisser de
-    # la place a la nouvelle generation.
     MAX_CONTEXT_TOKENS = int(os.getenv("MAX_CONTEXT_TOKENS", 1400))
     TOOL_RESULT_KEEP_CHARS = int(os.getenv("TOOL_RESULT_KEEP_CHARS", 300))
 
-
 def _valid_tokens() -> tuple:
     toks = [Config.API_TOKEN]
     if Config.LEGACY_TOKEN:
         toks.append(Config.LEGACY_TOKEN)
     return tuple(toks)
 
-
 # =================== RATE LIMITER ===================
 class RateLimiter:
     def __init__(self, max_requests: int, window: int):
@@ -138,10 +110,8 @@ class RateLimiter:
             self.requests[key].append(now)
             return True
 
-
 rate_limiter = RateLimiter(Config.RATE_LIMIT_REQUESTS, Config.RATE_LIMIT_WINDOW)
 
-
 # =================== BASE DE DONNEES (POOL ASYNC) ===================
 @dataclass
 class DBConnectionPool:
@@ -186,10 +156,6 @@ class DBConnectionPool:
     def _init_db(self):
         conn = sqlite3.connect(self.db_path)
         c = conn.cursor()
-        # Mode WAL : permet des lectures concurrentes pendant une ecriture
-        # (utile ici car plusieurs coroutines partagent le meme fichier
-        # SQLite via le pool de connexions) au lieu du mode par defaut qui
-        # verrouille toute la base pendant une transaction d'ecriture.
         c.execute("PRAGMA journal_mode=WAL;")
         c.execute("PRAGMA synchronous=NORMAL;")
         c.executescript('''
@@ -213,10 +179,6 @@ class DBConnectionPool:
                 prompt TEXT, answer TEXT, status TEXT, feedback TEXT,
                 chunks_used TEXT, created_at TEXT DEFAULT CURRENT_TIMESTAMP
             );
-            CREATE TABLE IF NOT EXISTS scrape_queue (
-                url TEXT PRIMARY KEY, priority INTEGER DEFAULT 0,
-                added_at TEXT DEFAULT CURRENT_TIMESTAMP, status TEXT DEFAULT 'pending'
-            );
             CREATE TABLE IF NOT EXISTS task_tracker (
                 task_id TEXT PRIMARY KEY, task_type TEXT, payload TEXT,
                 status TEXT DEFAULT 'pending', created_at TEXT DEFAULT CURRENT_TIMESTAMP,
@@ -257,10 +219,8 @@ class DBConnectionPool:
         conn.close()
         logger.info(f"DB initialisee: {self.db_path}")
 
-
 db_pool = DBConnectionPool(Config.DB_PATH)
 
-
 # =================== AUTH (REST) ===================
 async def verify_any_token(authorization: str = Header(...)):
     if not authorization.startswith("Bearer "):
@@ -272,7 +232,6 @@ async def verify_any_token(authorization: str = Header(...)):
         raise HTTPException(429, detail="Rate limit exceeded")
     return token
 
-
 # =================== VECTOR STORE ===================
 class VectorStore:
     def __init__(self):
@@ -352,10 +311,7 @@ class VectorStore:
             scored.sort(reverse=True)
             return [c.copy() for _, c in scored[:top_k]]
 
-
 vector_store = VectorStore()
-quarantine = QuarantineManager(Config.DATA_DIR / "quarantine")
-
 
 # =================== CHUNKING ===================
 class TextChunker:
@@ -377,36 +333,60 @@ class TextChunker:
             chunks.append(" ".join(current_chunk))
         return chunks
 
+# =================== QUARANTINE MANAGER ===================
+class QuarantineManager:
+    def __init__(self, quarantine_dir: Path):
+        self.dir = quarantine_dir
+        self.dir.mkdir(parents=True, exist_ok=True)
 
-# =================== RERANKER ===================
-class Reranker:
-    def __init__(self):
-        self.model = None
-        try:
-            self.model = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2', device=Config.DEVICE)
-            logger.info(f"Cross-Encoder charge sur {Config.DEVICE}")
-        except Exception as e:
-            logger.warning(f"Cross-Encoder desactive: {e}")
+    def list_pending(self) -> List[Dict]:
+        items = []
+        for f in sorted(self.dir.glob("*.json")):
+            try:
+                data = json.loads(f.read_text(encoding="utf-8"))
+                items.append({
+                    "id": f.stem,
+                    "source": data.get("source_url", "inconnue"),
+                    "title": data.get("title", ""),
+                    "summary": (data.get("content", "") or "")[:200],
+                    "timestamp": data.get("timestamp"),
+                })
+            except Exception:
+                continue
+        items.sort(key=lambda x: x.get("timestamp") or "", reverse=True)
+        return items
 
-    async def rerank(self, query, chunks, top_k=5):
-        if not chunks or self.model is None:
-            return chunks[:top_k]
-        pairs = [(query, c.get("content", "")) for c in chunks]
-        try:
-            loop = asyncio.get_running_loop()
-            scores = await loop.run_in_executor(None, self.model.predict, pairs)
-            for i, c in enumerate(chunks):
-                c["rerank_score"] = float(scores[i])
-            return sorted(chunks, key=lambda x: x.get("rerank_score", 0), reverse=True)[:top_k]
-        except Exception as e:
-            logger.error(f"Reranking echoue: {e}")
-            return chunks[:top_k]
+    def add(self, content: str, source_url: str = "", title: str = "") -> str:
+        doc_id = uuid.uuid4().hex[:8]
+        data = {
+            "id": doc_id,
+            "content": content,
+            "source_url": source_url,
+            "title": title,
+            "timestamp": datetime.utcnow().isoformat(),
+        }
+        (self.dir / f"{doc_id}.json").write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
+        return doc_id
 
+    def get(self, doc_id: str) -> Optional[Dict]:
+        f = self.dir / f"{doc_id}.json"
+        if not f.exists():
+            return None
+        try:
+            return json.loads(f.read_text(encoding="utf-8"))
+        except Exception:
+            return None
 
-reranker = Reranker()
+    def remove(self, doc_id: str) -> bool:
+        f = self.dir / f"{doc_id}.json"
+        if f.exists():
+            f.unlink()
+            return True
+        return False
 
+quarantine = QuarantineManager(Config.DATA_DIR / "quarantine")
 
-# =================== INFÉRENCE QWEN (1.5B, GPU) ===================
+# =================== INFÉRENCE QWEN ===================
 class LocalInference:
     def __init__(self):
         self.model = None
@@ -421,7 +401,7 @@ class LocalInference:
             self.model = AutoModelForCausalLM.from_pretrained(
                 Config.MODEL_NAME,
                 token=Config.HF_TOKEN,
-                dtype=torch.float16 if device == "cuda" else torch.float32,
+                torch_dtype=torch.float16 if device == "cuda" else torch.float32,
                 low_cpu_mem_usage=True,
             )
             self.model.to(device)
@@ -477,10 +457,9 @@ class LocalInference:
         parts.append("<|im_start|>assistant\n")
         return "".join(parts)
 
-
 inference = LocalInference()
 
-# =================== TOOLS ET AGENT ===================
+# =================== AGENT ===================
 TOOLS = [
     {"name": "read_file", "description": "Read file content", "parameters": {"path": {"type": "string"}}},
     {"name": "write_file", "description": "Write file", "parameters": {"path": {"type": "string"}, "content": {"type": "string"}}},
@@ -488,15 +467,8 @@ TOOLS = [
     {"name": "run_python", "description": "Run Python code", "parameters": {"code": {"type": "string"}}}
 ]
 
-
 class AgentV103:
-    # Nombre max de tentatives de "relance" quand le modele repond en texte
-    # libre (confusion / refus / hallucination d'un outil manquant) au lieu
-    # d'emettre un JSON d'appel d'outil valide, alors que la tache l'exige.
     MAX_NUDGES_PER_TASK = 2
-
-    # Signaux textuels typiques d'un petit modele qui "raconte" au lieu
-    # d'agir : hallucine un outil absent, s'excuse, ou explique sans agir.
     _CONFUSION_MARKERS = (
         "tool was not found", "tool not found", "no such tool",
         "i don't have", "i do not have", "unable to", "cannot find",
@@ -506,10 +478,6 @@ class AgentV103:
     def __init__(self, inference_client, tools):
         self.inference = inference_client
         self.tools = tools
-        # Le system prompt inclut desormais un exemple few-shot complet
-        # (tache -> appel d'outil -> resultat -> reponse finale). Un modele
-        # causal de cette taille (1.5B) suit un exemple concret beaucoup
-        # plus fiablement qu'une regle enoncee seule.
         self.system_prompt = """You are an expert development agent in ADN NEXUS IDE.
 You have access to these tools:
 - read_file(path) -> reads file content
@@ -548,9 +516,6 @@ Your next response, now that you have the output:
         return any(marker in lowered for marker in self._CONFUSION_MARKERS)
 
     def _score_candidate(self, tool_call: Optional[dict], result: Optional[dict], text: str) -> float:
-        """Heuristique simple pour departager plusieurs candidats generes en
-        parallele (mode raisonnement). Favorise un appel d'outil reussi et
-        propre plutot qu'une reponse textuelle vague ou confuse."""
         score = 0.0
         if tool_call:
             score += 0.4
@@ -565,17 +530,9 @@ Your next response, now that you have the output:
         return score
 
     async def run_task_with_reasoning(self, session_id, task, websocket, max_candidates: Optional[int] = None):
-        """Variante optionnelle de run_task : genere plusieurs candidats avec
-        un vrai echantillonnage stochastique (do_sample=True, temperature)
-        pour la toute premiere reponse de la tache, execute chacun, les
-        note, et poursuit la boucle normale (deterministe, avec le meme
-        few-shot + retry que run_task) a partir du meilleur. Diversifier
-        uniquement la premiere etape borne le cout — diversifier chaque
-        etape d'une boucle a 5 iterations multiplierait le temps de calcul
-        sans gain proportionnel sur un modele de cette taille."""
         n = max_candidates or Config.SAMPLING_CANDIDATES
         base_messages = [{"role": "system", "content": self.system_prompt},
-                          {"role": "user", "content": task}]
+                         {"role": "user", "content": task}]
         candidates = []
         for i in range(n):
             response = await self.inference.generate(
@@ -612,14 +569,9 @@ Your next response, now that you have the output:
                 await websocket.send_json({"type": "complete", "result": best["response"]})
                 return {"success": True, "result": best["response"], "best_score": best["score"]}
 
-        # Poursuite de la tache avec la boucle standard (deterministe,
-        # few-shot + retry deja valides) a partir de l'etat construit.
         return await self._continue_task(messages, websocket, start_iteration=1)
 
     def _estimate_tokens(self, messages: list) -> int:
-        """Compte le nombre reel de tokens que produirait ces messages une
-        fois formates pour Qwen, via le tokenizer deja charge — pas une
-        approximation par nombre de caracteres."""
         tok = getattr(self.inference, "tokenizer", None)
         if tok is None:
             return 0
@@ -627,16 +579,9 @@ Your next response, now that you have the output:
         return len(tok(prompt)["input_ids"])
 
     def _compress_old_tool_results(self, messages: list) -> list:
-        """Nettoyage cible deterministe : tronque le contenu des anciens
-        messages de role 'tool' (garde les plus recents intacts) au lieu
-        de les envoyer en entier. Ne touche jamais le system prompt ni le
-        premier message utilisateur (la tache d'origine), et laisse
-        toujours les 2 derniers echanges (assistant+tool) intacts pour que
-        le modele garde le contexte immediat necessaire a la suite."""
-        # Compte les indices des messages 'tool' du plus recent au plus ancien
         tool_indices = [i for i, m in enumerate(messages) if m.get("role") == "tool"]
         if len(tool_indices) <= 2:
-            return messages  # rien a compresser, peu d'historique
+            return messages
         keep_recent = set(tool_indices[-2:])
 
         compressed = []
@@ -654,9 +599,6 @@ Your next response, now that you have the output:
         return compressed
 
     def _enforce_context_budget(self, messages: list) -> list:
-        """Applique le nettoyage cible si et seulement si l'historique
-        depasse le seuil configure — evite de degrader inutilement une
-        tache courte."""
         if self._estimate_tokens(messages) <= Config.MAX_CONTEXT_TOKENS:
             return messages
         compressed = self._compress_old_tool_results(messages)
@@ -739,121 +681,7 @@ Your next response, now that you have the output:
             result = {"success": False, "error": f"Tool {name} unknown"}
         return result
 
-
-# =================== SCRAPING ===================
-scrape_queue = asyncio.Queue(maxsize=Config.QUEUE_MAXSIZE)
-scrape_worker_running = True
-scrape_workers = []
-
-
-async def scrape_worker(worker_id):
-    logger.info(f"Worker {worker_id} demarre")
-    while scrape_worker_running:
-        try:
-            url_data = await asyncio.wait_for(scrape_queue.get(), timeout=5.0)
-            url = url_data.get("url")
-            logger.info(f"Worker {worker_id}: {url}")
-            success, content, title = await _scrape_url(url)
-            if success:
-                await vector_store.add(content=content, metadata={"title": title, "url": url}, source_url=url)
-                await db_pool.execute("UPDATE source_states SET last_scraped = ?, status = ? WHERE url = ?",
-                                       (datetime.utcnow().isoformat(), "ok", url))
-                logger.info(f"Worker {worker_id}: {url} -> OK")
-            else:
-                await db_pool.execute("UPDATE source_states SET status = ? WHERE url = ?", (f"error_{content}", url))
-                logger.warning(f"Worker {worker_id}: echec {url}")
-            scrape_queue.task_done()
-        except asyncio.TimeoutError:
-            continue
-        except Exception as e:
-            logger.error(f"Worker {worker_id} erreur: {e}")
-            try:
-                scrape_queue.task_done()
-            except Exception:
-                pass
-    logger.info(f"Worker {worker_id} arrete")
-
-
-async def _scrape_url(url):
-    headers = {"User-Agent": "Mozilla/5.0"}
-    try:
-        resp = requests.get(url, headers=headers, timeout=15)
-        if resp.status_code != 200:
-            return False, str(resp.status_code), "Error"
-        soup = BeautifulSoup(resp.text, 'html.parser')
-        title = soup.title.string if soup.title else "No title"
-        for tag in soup(["script", "style", "nav", "footer", "header", "aside"]):
-            tag.decompose()
-        paragraphs = [p.get_text(strip=True) for p in soup.find_all('p') if len(p.get_text(strip=True)) > 20]
-        content = "\n".join(paragraphs)
-        if len(content) < 100:
-            article = soup.find('article') or soup.find('main') or soup.body
-            if article:
-                content = article.get_text(separator='\n', strip=True)
-        content = content[:Config.MAX_CONTENT_LENGTH]
-        return True, content, title
-    except Exception as e:
-        return False, str(e), "Error"
-
-
 # =================== FILE MANAGER ===================
-class QuarantineManager:
-    """Zone de quarantaine pour le contenu extrait avant indexation.
-    Stockage fichier (JSON), pas de nouvelle base de donnees — coherent
-    avec la contrainte CPU/pas-de-budget : aucune dependance ajoutee,
-    aucun processus en arriere-plan (extraction a la demande uniquement,
-    contrairement aux anciens workers de scraping continus)."""
-
-    def __init__(self, quarantine_dir: Path):
-        self.dir = quarantine_dir
-        self.dir.mkdir(parents=True, exist_ok=True)
-
-    def list_pending(self) -> List[Dict]:
-        items = []
-        for f in sorted(self.dir.glob("*.json")):
-            try:
-                data = json.loads(f.read_text(encoding="utf-8"))
-                items.append({
-                    "id": f.stem,
-                    "source": data.get("source_url", "inconnue"),
-                    "title": data.get("title", ""),
-                    "summary": (data.get("content", "") or "")[:200],
-                    "timestamp": data.get("timestamp"),
-                })
-            except Exception:
-                continue
-        items.sort(key=lambda x: x.get("timestamp") or "", reverse=True)
-        return items
-
-    def add(self, content: str, source_url: str = "", title: str = "") -> str:
-        doc_id = uuid.uuid4().hex[:8]
-        data = {
-            "id": doc_id,
-            "content": content,
-            "source_url": source_url,
-            "title": title,
-            "timestamp": datetime.utcnow().isoformat(),
-        }
-        (self.dir / f"{doc_id}.json").write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
-        return doc_id
-
-    def get(self, doc_id: str) -> Optional[Dict]:
-        f = self.dir / f"{doc_id}.json"
-        if not f.exists():
-            return None
-        try:
-            return json.loads(f.read_text(encoding="utf-8"))
-        except Exception:
-            return None
-
-    def remove(self, doc_id: str) -> bool:
-        f = self.dir / f"{doc_id}.json"
-        if f.exists():
-            f.unlink()
-            return True
-        return False
-
-
 class FileManager:
     ROOT = Config.WORKSPACE_ROOT
 
@@ -892,10 +720,8 @@ class FileManager:
         except Exception as e:
             return {"success": False, "error": str(e)}
 
-
 file_mgr = FileManager()
 
-
 # =================== SANDBOX ===================
 class Sandbox:
     async def run_python(self, code, timeout=30):
@@ -921,9 +747,6 @@ class Sandbox:
             Path(temp_path).unlink(missing_ok=True)
 
     async def run_command(self, args: list, timeout=30):
-        """Execute une commande arbitraire (liste d'arguments, pas de shell=True)
-        dans le workspace. Utilise par les actions rapides deterministes
-        (Tests, Fix) qui n'ont pas besoin de passer par la decision du LLM."""
         try:
             proc = await asyncio.create_subprocess_exec(
                 *args,
@@ -940,10 +763,8 @@ class Sandbox:
         except Exception as e:
             return {"success": False, "error": str(e), "stdout": "", "stderr": ""}
 
-
 sandbox = Sandbox()
 
-
 # =================== TELEMETRY ===================
 class RuntimeTelemetry:
     def __init__(self, workspace):
@@ -966,26 +787,29 @@ class RuntimeTelemetry:
         finally:
             Path(temp_path).unlink(missing_ok=True)
 
-
 telemetry = RuntimeTelemetry(Config.WORKSPACE_ROOT)
 
-
-# =================== API CONTRACT PARSER ===================
-class APIContractParser:
-    @staticmethod
-    def parse_openapi(path):
-        content = Path(path).read_text()
-        spec = yaml.safe_load(content) if path.suffix in ('.yaml', '.yml') else json.loads(content)
-        endpoints = []
-        for p, methods in spec.get('paths', {}).items():
-            for m, d in methods.items():
-                if m in ('get', 'post', 'put', 'patch', 'delete'):
-                    endpoints.append({"path": p, "method": m.upper(), "operation_id": d.get('operationId')})
-        return {"title": spec.get('info', {}).get('title'), "version": spec.get('info', {}).get('version'), "endpoints": endpoints}
-
-
-contract_parser = APIContractParser()
-
+# =================== SCRAPING (extraction à la demande uniquement) ===================
+async def _scrape_url(url):
+    headers = {"User-Agent": "Mozilla/5.0"}
+    try:
+        resp = requests.get(url, headers=headers, timeout=15)
+        if resp.status_code != 200:
+            return False, str(resp.status_code), "Error"
+        soup = BeautifulSoup(resp.text, 'html.parser')
+        title = soup.title.string if soup.title else "No title"
+        for tag in soup(["script", "style", "nav", "footer", "header", "aside"]):
+            tag.decompose()
+        paragraphs = [p.get_text(strip=True) for p in soup.find_all('p') if len(p.get_text(strip=True)) > 20]
+        content = "\n".join(paragraphs)
+        if len(content) < 100:
+            article = soup.find('article') or soup.find('main') or soup.body
+            if article:
+                content = article.get_text(separator='\n', strip=True)
+        content = content[:Config.MAX_CONTENT_LENGTH]
+        return True, content, title
+    except Exception as e:
+        return False, str(e), "Error"
 
 # =================== GIT ANALYZER ===================
 class GitGraphAnalyzer:
@@ -1007,7 +831,6 @@ class GitGraphAnalyzer:
         except Exception:
             return []
 
-
 git_analyzer = None
 try:
     git_dir = Config.WORKSPACE_ROOT / '.git'
@@ -1019,8 +842,22 @@ try:
 except Exception as e:
     logger.warning(f"Git analyzer non disponible: {e}")
 
+# =================== API CONTRACT PARSER ===================
+class APIContractParser:
+    @staticmethod
+    def parse_openapi(path):
+        content = Path(path).read_text()
+        spec = yaml.safe_load(content) if path.suffix in ('.yaml', '.yml') else json.loads(content)
+        endpoints = []
+        for p, methods in spec.get('paths', {}).items():
+            for m, d in methods.items():
+                if m in ('get', 'post', 'put', 'patch', 'delete'):
+                    endpoints.append({"path": p, "method": m.upper(), "operation_id": d.get('operationId')})
+        return {"title": spec.get('info', {}).get('title'), "version": spec.get('info', {}).get('version'), "endpoints": endpoints}
+
+contract_parser = APIContractParser()
 
-# =================== KNOWLEDGE GRAPH ===================
+# =================== KNOWLEDGE GRAPH LOADER ===================
 class KnowledgeGraphLoader:
     def __init__(self, db_path="/tmp/kg.db"):
         self.db_path = db_path
@@ -1042,10 +879,8 @@ class KnowledgeGraphLoader:
         conn.close()
         return [dict(r) for r in rows]
 
-
 kg_loader = KnowledgeGraphLoader()
 
-
 # =================== KNOWLEDGE UNIFIER ===================
 class KnowledgeUnifier:
     def __init__(self):
@@ -1064,13 +899,12 @@ class KnowledgeUnifier:
                 parts.append(f"- {v.get('name', '')} ({v.get('type', '')})")
         return "\n".join(parts) if parts else "No context available"
 
-
 unifier = KnowledgeUnifier()
 
 # =================== AGENT INSTANCIATION ===================
 agent = AgentV103(inference, TOOLS)
 
-# =================== CLIENT HTML (login screen — pas de token en dur) ===================
+# =================== CLIENT HTML ===================
 IDE_HTML = """<!DOCTYPE html>
 <html lang="fr">
 <head>
@@ -1180,9 +1014,6 @@ document.addEventListener('DOMContentLoaded', () => {
 });
 
 function connectWs(){
-    // Le token n'est plus jamais mis dans l'URL (query string) : il est
-    // envoye comme premier message JSON juste apres l'ouverture, pour ne
-    // laisser aucune trace du secret dans les logs d'acces du proxy.
     const WS_URL = (location.protocol === 'https:' ? 'wss://' : 'ws://') + location.host + '/ws';
     ws = new WebSocket(WS_URL);
     let authenticated = false;
@@ -1266,10 +1097,6 @@ function sendTask(){
     ws.send(JSON.stringify({action:'agent', task:t, use_reasoning: useReasoning}));
 }
 function clearChat(){ document.getElementById('chat').innerHTML = ''; }
-// Les boutons rapides (Tests/Fix/Explain) sont des actions deterministes :
-// on sait deja quoi executer, donc on ne passe pas par la boucle agentique
-// (qui laisse le LLM decider quel outil appeler). Cela evite les esquives
-// que peut produire un petit modele face a une decision d'outil.
 function qTest(){ addMsg('u','Run all tests and report failures'); ws.send(JSON.stringify({action:'quick_test'})); }
 function qFix(){ addMsg('u','Scan for bugs and fix them'); ws.send(JSON.stringify({action:'quick_fix'})); }
 function qExp(){
@@ -1277,9 +1104,6 @@ function qExp(){
     addMsg('u','Explain '+curFile);
     ws.send(JSON.stringify({action:'quick_explain', path:curFile}));
 }
-// La zone de texte libre ("Describe what to build...") reste sur le
-// pipeline agentique complet : c'est la seule ou un vrai raisonnement
-// multi-etapes (choix d'outil inclus) est necessaire.
 function sendDirect(t){ addMsg('u',t); ws.send(JSON.stringify({action:'agent', task:t, use_reasoning:false})); }
 function runTelemetry(){
     if (!curFile){ alert('No file open'); return; }
@@ -1304,6 +1128,36 @@ function log(msg, type='out'){
 function accDiff(){ document.getElementById('diff').classList.remove('show'); }
 function rejDiff(){ document.getElementById('diff').classList.remove('show'); }
 
+function extractUrl(){
+    const url = document.getElementById('qurl').value.trim();
+    if(!url){ alert('Entrez une URL valide.'); return; }
+    ws.send(JSON.stringify({action:'extract_url', url}));
+}
+function renderQuarantine(data){
+    const container = document.getElementById('qlist');
+    if(!data || !data.length){
+        container.innerHTML = '<div style="color:var(--text2);font-size:11px;">Aucun document en attente.</div>';
+        return;
+    }
+    let html = '';
+    data.forEach(item => {
+        html += `<div style="background:var(--bg2);padding:6px 8px;border-radius:4px;font-size:11px;display:flex;justify-content:space-between;align-items:center;border-left:2px solid var(--yellow);">
+            <div><strong style="color:var(--accent)">${item.id}</strong> — ${item.title||'Sans titre'} (${item.source||'source inconnue'})</div>
+            <div>
+                <button style="background:var(--green);border:none;color:#000;padding:2px 6px;border-radius:4px;cursor:pointer;font-size:10px;" onclick="approveDoc('${item.id}')">Approuver</button>
+                <button style="background:var(--red);border:none;color:#fff;padding:2px 6px;border-radius:4px;cursor:pointer;font-size:10px;" onclick="rejectDoc('${item.id}')">Rejeter</button>
+            </div>
+        </div>`;
+    });
+    container.innerHTML = html;
+}
+function approveDoc(id){
+    ws.send(JSON.stringify({action:'quarantine_approve', id}));
+}
+function rejectDoc(id){
+    ws.send(JSON.stringify({action:'quarantine_reject', id}));
+}
+
 window.addEventListener('keydown', e => {
     if (e.ctrlKey && e.key === 's') { e.preventDefault(); saveFile(); }
 });
@@ -1320,86 +1174,56 @@ async def lifespan(app: FastAPI):
     db_pool._init_db()
     await db_pool.initialize()
     await vector_store.load_from_db()
-    for i in range(Config.NUM_SCRAPE_WORKERS):
-        worker = asyncio.create_task(scrape_worker(i))
-        scrape_workers.append(worker)
     logger.info("=" * 50)
     logger.info("ADN NEXUS V10.3.2 Agentic IDE demarre")
     logger.info(f"Workspace: {Config.WORKSPACE_ROOT}")
-    logger.info(f"Workers: {Config.NUM_SCRAPE_WORKERS}")
+    logger.info(f"Extraction web : a la demande uniquement (aucun worker permanent)")
     logger.info("=" * 50)
     yield
-    logger.info("Arret en cours...")
-    global scrape_worker_running
-    scrape_worker_running = False
-    for w in scrape_workers:
-        w.cancel()
-        try:
-            await w
-        except asyncio.CancelledError:
-            pass
     logger.info("Arret complet")
 
-
 app = FastAPI(title="ADN NEXUS V10.3.2", version="10.3.2", lifespan=lifespan,
               docs_url=None, redoc_url=None, openapi_url=None)
-# credentials=False : l'auth se fait par token applicatif (Bearer / query param),
-# pas par cookie de session — combiner allow_origins="*" avec allow_credentials=True
-# n'a pas de sens ici et est deconseille par la spec CORS.
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=False, allow_methods=["*"], allow_headers=["*"])
 
-
 # =================== ROUTES ===================
 @app.get("/")
 async def root():
     return HTMLResponse(content=IDE_HTML)
 
-
 @app.get("/health")
 async def health():
     return {"status": "ok", "version": "10.3.2", "gpu": "T4"}
 
-
 @app.get("/workspace")
 async def list_workspace(token: str = Depends(verify_any_token)):
     return file_mgr.list_dir("")
 
-
 @app.get("/file")
 async def read_file(path: str, token: str = Depends(verify_any_token)):
     return file_mgr.read(path)
 
-
 @app.post("/file")
 async def write_file(data: dict, token: str = Depends(verify_any_token)):
     return file_mgr.write(data.get("path"), data.get("content"))
 
-
 @app.post("/run")
 async def run_code(data: dict, token: str = Depends(verify_any_token)):
     return await sandbox.run_python(data.get("code", ""))
 
-
 @app.post("/agent")
 async def agent_task(data: dict, token: str = Depends(verify_any_token)):
     session_id = str(uuid.uuid4())
     result = await agent.run_task(session_id, data.get("task", ""), DummyWebSocket())
     return result
 
-
 class DummyWebSocket:
     async def send_json(self, data):
         logger.info(f"Agent: {data}")
 
-
 # =================== WEBSOCKET AVEC AUTH ===================
 @app.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket):
-    # Authentification par PREMIER MESSAGE plutot que par query string.
-    # Le token en query param finit dans les logs d'acces du proxy (HF
-    # Spaces, reverse proxies) meme apres rotation — un risque residuel
-    # qu'on ferme ici. On accepte la connexion TCP/WS puis on exige un
-    # premier message JSON {"token": "..."} avant tout traitement.
     client_host = websocket.client.host if websocket.client else "unknown"
     if not await rate_limiter.is_allowed(f"ws-preauth:{client_host}"):
         await websocket.close(code=1013, reason="Rate limit exceeded")
@@ -1451,11 +1275,6 @@ async def websocket_endpoint(websocket: WebSocket):
                     result = await agent.run_task(session_id, task, websocket)
                 await websocket.send_json({"type": "agent_result", "data": result})
             elif action == "quick_test":
-                # Action deterministe : on sait deja quelle commande executer,
-                # inutile de laisser un petit modele "decider" d'appeler un
-                # outil — on l'execute directement et on ne sollicite le LLM
-                # que pour resumer un resultat deja connu (pas de JSON a
-                # produire, donc pas de risque d'esquive).
                 result = await sandbox.run_command([sys.executable, "-m", "pytest", "-q"])
                 summary = await inference.generate([
                     {"role": "system", "content": "You are a coding assistant. Summarize this pytest output concisely in plain text for a developer: how many passed/failed, and the key error if any. No JSON, no tool calls."},
@@ -1487,9 +1306,6 @@ async def websocket_endpoint(websocket: WebSocket):
                         ], max_tokens=400, do_sample=False)
                         await websocket.send_json({"type": "agent_result", "data": {"success": True, "result": summary}})
             elif action == "extract_url":
-                # Extraction A LA DEMANDE (pas de worker en arriere-plan) :
-                # une seule requete HTTP, resultat mis en quarantaine — rien
-                # n'est indexe tant que l'utilisateur n'a pas approuve.
                 url = msg.get("url", "").strip()
                 if not url:
                     await websocket.send_json({"type": "quarantine_result", "data": {"success": False, "error": "URL manquante."}})
@@ -1553,7 +1369,6 @@ async def websocket_endpoint(websocket: WebSocket):
         except Exception:
             pass
 
-
 # =================== LANCEMENT ===================
 if __name__ == "__main__":
     import uvicorn