@piecemaker-legal/piecemaker 2.0.15 → 2.0.17

package/server/piecemaker/vendor/piecemaker-plugin/skills/recherche-juridique/SKILL.md

@@ -22,51 +22,37 @@ effectivement disponibles, puis le format exact que le vérificateur accepte.
 
 | Outil | Rôle |
 | --- | --- |
-| `Search_Cour_Cassation` | Recherche ciblée dans la jurisprudence de la Cour de cassation (mots-clés, opérateurs ET/OU, expression exacte, référence d'article), filtrable par matière et publication au bulletin. |
-| `Search_Conseil_Etat` | Même recherche ciblée dans la jurisprudence du Conseil d'État, filtrable par publication au recueil Lebon. |
-| `Search_Cour_Appel` | Même recherche dans les cours d'appel, filtrable par ville — bien cibler (ville + dates), le volume est important. |
-| `Search_CAA` | Même recherche dans les cours administratives d'appel, filtrable par ville. |
-| `Search_Premiere_Instance` | Recherche dans les juridictions de première instance — volume très limité (~50 décisions), opérateur OU par défaut. |
+| `Search_Jurisprudence` | Seul outil de recherche jurisprudentielle : interroge en un appel Légifrance et Judilibre pour la Cour de cassation, les cours d'appel, la première instance, le Conseil d'État et les CAA, avec les mêmes filtres (`matiere` obligatoire en cassation, publication, villes, `types_premiere_instance` obligatoire en première instance, recueil Lebon, dates) et la même requête (guillemets, `ET`, `OU`, parenthèses, articles). Les doublons Légifrance/Judilibre sont fusionnés ; au-delà de 500 résultats cumulés, la recherche est refusée. |
 | `Search_Code` | Recherche dans les codes juridiques français (Code civil, Code du travail…) — référence d'article exacte (`L. 1235-3`), mots-clés ou expression exacte. Renvoie les identifiants `LEGIARTI…` des articles trouvés. |
 | `consulter_article` | Texte intégral et vigueur d'une version précise d'article, à partir de son identifiant `LEGIARTI…` rendu par `Search_Code`. |
-| `consulter_decision` | Rapatrie le texte intégral d'une décision à partir de son identifiant (`JURITEXT…`, `CETATEXT…`). **Rapatrie le texte intégral et le met en cache** (voir plus bas) — c'est le moyen normal de lire une décision avant de la citer. |
-| `Download_Query_Results` | Télécharge en masse tous les résultats d'une requête dans un dossier local, pour trier sans paginer. **Ne rapatrie pas le texte intégral** (voir l'avertissement ci-dessous) — sert au tri, jamais directement à la citation. |
-| `Build_Research_Corpus` | Construit un corpus exhaustif et reproductible sur une question de droit : plusieurs requêtes, déduplication, téléchargement et scan du texte intégral de chaque décision. **Rapatrie le texte intégral.** À utiliser pour une recherche large et systématique plutôt qu'un enchaînement manuel de `Search_*`. |
-| `Validate_Research_Cards` | Valide mécaniquement (sans LLM) le résultat de `Build_Research_Corpus` : une fiche par décision, citations confirmées dans le texte intégral, rapport de couverture. |
+| `consulter_decision` | Rapatrie le texte intégral d'une décision à partir de son identifiant Légifrance (`JURITEXT…`, `CETATEXT…`) ou Judilibre (24 caractères hexadécimaux). **Rapatrie le texte intégral et le met en cache** (voir plus bas) — c'est le moyen normal de lire une décision avant de la citer. |
+| `Build_Research_Corpus` | Construit un corpus exhaustif et reproductible sur une question de droit : une formulation, recherchée par le même moteur et avec les mêmes filtres que `Search_Jurisprudence`, déduplication, téléchargement et scan du texte intégral de chaque décision. **Rapatrie le texte intégral.** À utiliser pour une recherche large et systématique plutôt qu'une suite de pages de `Search_Jurisprudence`. |
 | `Tracking_BODACC` | Situation d'une entreprise (procédures collectives) via son SIREN — hors jurisprudence, utile pour qualifier une partie. |
 
 ### Le fait décisif : seuls deux chemins rendent une citation vérifiable
 
 Le vérificateur ne peut confirmer une citation que si le texte intégral de sa
-source est quelque part sur disque. Sur les trois façons dont le MCP restitue
-une décision, **une seule ne rapatrie pas ce texte** :
+source est quelque part sur disque :
 
 - **`Build_Research_Corpus`** écrit `decisions.jsonl` (une décision par ligne,
   champ `texte` = texte intégral réel) — vérifiable.
 - **`consulter_decision`** renvoie le texte intégral dans sa réponse d'outil ;
   le hook `decision-cache.mjs` le capte au passage et l'écrit dans
   `~/.piecemaker/decisions/<id>.json` — vérifiable.
-- **`Download_Query_Results`** écrit `results.json`, mais chaque entrée ne
-  contient que `id`, `titre`, `lien`, `date`, `analyse` (un sommaire) et,
-  optionnellement, `solution.dispositif` (le dispositif seul — jamais les
-  motifs). **Pas de texte intégral.** Citer une décision connue uniquement par
-  ce canal produira une citation non vérifiée et bloquera le tour.
-
-**Conséquence pratique** : `Download_Query_Results` sert à trier une liste de
-résultats (lire les titres/sommaires, écarter le hors-sujet). Dès qu'une
-décision de cette liste doit être citée, il faut d'abord la lire avec
-`consulter_decision` (ou l'avoir dans un corpus `Build_Research_Corpus`) —
-jamais citer directement depuis `results.json`.
+
+**Conséquence pratique** : les résultats de `Search_Jurisprudence` (titre,
+analyse, extraits) servent à trier. Dès qu'une décision doit être citée, il
+faut d'abord la lire avec `consulter_decision` (ou l'avoir dans un corpus
+`Build_Research_Corpus`).
 
 ## Déroulé de recherche
 
-1. **Recherche large** avec l'outil `Search_*` adapté à la juridiction visée
+1. **Recherche large** avec `Search_Jurisprudence` sur les juridictions visées
    (ou `Build_Research_Corpus` pour une question de droit qui mérite un
    balayage systématique plutôt qu'une requête isolée). Pour un texte de loi,
    `Search_Code`.
-2. **Tri** des résultats sur les seuls éléments déjà renvoyés (titre, sommaire,
-   date, `analyse`) — sans lire chaque décision en entier. `Download_Query_Results`
-   aide à trier un grand volume hors ligne.
+2. **Tri** des résultats sur les seuls éléments déjà renvoyés (titre, analyse,
+   date, extraits) — sans lire chaque décision en entier.
 3. **Lecture** des seules décisions/articles retenus comme potentiellement
    cite-worthy : `consulter_decision` (jurisprudence) ou `consulter_article`
    (texte de loi), ou relecture du `decisions.jsonl` d'un corpus déjà construit.
@@ -114,9 +100,9 @@ prend l'une des deux formes suivantes.
 ### Forme « jurisprudence » (`kind: "case"`)
 
 Identifie la décision par `decision_id` — l'identifiant Légifrance
-(`JURITEXT…`, `CETATEXT…`) tel que rendu par `Search_*`/`Download_Query_Results`/
-`Build_Research_Corpus`, et lu avec `consulter_decision` (ou présent dans un
-`decisions.jsonl`).
+(`JURITEXT…`, `CETATEXT…`) ou Judilibre (24 caractères hexadécimaux) tel que
+rendu par `Search_Jurisprudence`/`Build_Research_Corpus`, et lu avec
+`consulter_decision` (ou présent dans un `decisions.jsonl`).
 
 ```json
 {
@@ -208,9 +194,8 @@ retombe sur un tableau `quotes` d'un seul élément :
 
 1. Parse le bloc `<CITATIONS>` du dernier message.
 2. Pour chaque citation, résout sa source réelle — texte intégral de la
-   décision (corpus `Build_Research_Corpus`, cache `consulter_decision`, ou en
-   dernier recours le sommaire de `Download_Query_Results`) ou pièce
-   Markdown du dossier.
+   décision (corpus `Build_Research_Corpus` ou cache `consulter_decision`) ou
+   pièce Markdown du dossier.
 3. Localise mécaniquement chaque extrait dans ce texte. Un extrait qui a
    légèrement dérivé (espace, casse, ponctuation) est **corrigé
    automatiquement** avec l'extrait source exact — ce n'est pas une faute.
@@ -224,8 +209,8 @@ citation si elle ne peut pas être justifiée par une source effectivement lue.
 
 ## Ce qu'il ne faut pas faire
 
-- Ne jamais citer une décision connue uniquement par un résultat
-  `Download_Query_Results` sans l'avoir d'abord lue avec `consulter_decision`.
+- Ne jamais citer une décision connue uniquement par un résultat de
+  `Search_Jurisprudence` sans l'avoir d'abord lue avec `consulter_decision`.
 - Ne jamais paraphraser un extrait pour qu'il « sonne » comme la source — le
   vérificateur tolère l'espace/la casse/la ponctuation, pas le sens.
 - Ne jamais laisser un `ref` sauter un numéro ou repartir en désordre.

package/server/piecemaker/vendor/websocket-server/admin-routes.cjs

@@ -1638,7 +1638,12 @@ function startInstallJob(repoRoot, component) {
     windowsHide: true,
     stdio: ['ignore', 'pipe', 'pipe'],
     // PIECEMAKER_YES=1 : accepte les valeurs par défaut (MinerU inclus) sans TTY.
-    env: { ...process.env, PIECEMAKER_YES: '1', NO_COLOR: '1' },
+    env: {
+      ...process.env,
+      PIECEMAKER_YES: '1',
+      NO_COLOR: '1',
+      ...(component === 'mineru' ? { PIECEMAKER_INSTALL_MINERU: '1' } : {}),
+    },
   });
   const tailStderr = [];
   const onLine = (chunk) => {

package/server/piecemaker/vendor/websocket-server/originals-pipeline.cjs

@@ -255,6 +255,14 @@ function spawnTracked(job, script, args, progressScale = {}, io = {}) {
           }
           continue;
         }
+        if (line.startsWith('OCR_REQUIRED:')) {
+          try {
+            io.onOcrRequired?.(JSON.parse(line.slice('OCR_REQUIRED:'.length)));
+          } catch (error) {
+            errorLines.push(`pièces à OCR illisibles : ${error.message}`);
+          }
+          continue;
+        }
         const progress = /^PROGRESS:([A-Z]+):(\d+):(\d+):(\d+)/.exec(line.trim());
         if (!progress) continue;
         const [, marker, pct, current, total] = progress;
@@ -341,7 +349,7 @@ function spawnTracked(job, script, args, progressScale = {}, io = {}) {
  * `onProgress`, si fourni, est appelé à chaque mise à jour de la progression
  * avec `{ phase, percent, processed, total }`.
  */
-function runManagedPythonJob({ action, script, args, onProgress, signal, input, onMapping } = {}) {
+function runManagedPythonJob({ action, script, args, onProgress, signal, input, onMapping, onOcrRequired } = {}) {
   if (!['convert', 'anonymize'].includes(action)) throw new Error('Action inconnue.');
   if (!acceptingJobs) throw new Error('Le serveur est en cours d’arrêt : aucun nouveau traitement ne peut démarrer.');
   const job = {
@@ -375,7 +383,7 @@ function runManagedPythonJob({ action, script, args, onProgress, signal, input,
     if (signal.aborted) abort();
     else signal.addEventListener('abort', abort, { once: true });
   }
-  const run = () => spawnTracked(job, script, args, {}, { input, onMapping });
+  const run = () => spawnTracked(job, script, args, {}, { input, onMapping, onOcrRequired });
   const descriptor = { job, run };
   const completion = new Promise((resolve, reject) => {
     descriptor.resolve = resolve;

package/server/piecemaker/vendor/websocket-server/scripts/convert_and_scan_pipeline.py

@@ -50,7 +50,10 @@ from contextlib import closing
 from pathlib import Path
 from typing import List, Optional, Tuple, Dict, Set
 
+from smart_converter import mineru_available, needs_ocr
 
+
+EXIT_OCR_REQUIRED = 3
 GLINER_CHUNK_SIZE = 384
 GLINER_CHUNK_OVERLAP = 64
 
@@ -1575,7 +1578,9 @@ def source_is_anonymized(state: Dict, source_file: str, case_root: str) -> bool:
     return source_is_processed(state, source_file, case_root, "scanned")
 
 
-def update_processing_state(state_path: Path, case_root: str, source_files: List[str], phase: str) -> None:
+def update_processing_state(
+    state_path: Path, case_root: str, source_files: List[str], phase: str, ocr_missing: bool = False
+) -> None:
     """Atomically add successful conversions/scans without paths or entities."""
     if not source_files:
         return
@@ -1587,9 +1592,12 @@ def update_processing_state(state_path: Path, case_root: str, source_files: List
             continue
         fingerprint = {**source_fingerprint(source_file), "updatedAt": updated_at}
         entry = state["files"].get(key, {})
+        previous_ocr = entry.get("converted", {}).get("ocr")
         entry[phase] = fingerprint
+        if phase == "converted" and ocr_missing:
+            entry["converted"] = {**fingerprint, "ocr": "missing"}
         if phase == "scanned":
-            entry["converted"] = fingerprint
+            entry["converted"] = {**fingerprint, **({"ocr": previous_ocr} if previous_ocr else {})}
         state["files"][key] = entry
     state_path.parent.mkdir(parents=True, exist_ok=True)
     temporary = state_path.with_name(f"{state_path.name}.piecemaker-{os.getpid()}.tmp")
@@ -1800,6 +1808,15 @@ def run_pipeline(resources: PipelineResources):
         help="MinerU processing mode (only used if engine=mineru)",
     )
     parser.add_argument("--lang", help="OCR language code (only used if engine=mineru)")
+    parser.add_argument(
+        "--ocr-missing",
+        choices=["ask", "continue"],
+        default="continue",
+        help=(
+            "When scanned documents need OCR but MinerU is not installed: 'ask' stops before "
+            "any work and prints OCR_REQUIRED:<json>; 'continue' converts them from their text layer only"
+        ),
+    )
     parser.add_argument(
         "--document-id",
         default="default",
@@ -1871,7 +1888,36 @@ def run_pipeline(resources: PipelineResources):
     def markdown_path(input_file: str) -> Path:
         return Path(args.output) / f"{Path(input_file).stem}.md"
 
-    scan_needed = any(
+    mineru_ready = args.engine == "mineru" or (args.engine == "auto" and mineru_available())
+
+    def converted_without_ocr(input_file: str) -> bool:
+        entry = source_state_entry(anonymization_state, input_file, state_case_root) or {}
+        return entry.get("converted", {}).get("ocr") == "missing"
+
+    def markdown_is_reusable(input_file: str) -> bool:
+        if not markdown_path(input_file).exists():
+            return False
+        if mineru_ready and converted_without_ocr(input_file):
+            return False
+        state_entry = source_state_entry(anonymization_state, input_file, state_case_root)
+        return state_entry is None or source_is_converted(anonymization_state, input_file, state_case_root)
+
+    def case_relative_name(input_file: str) -> str:
+        try:
+            return Path(input_file).resolve().relative_to(Path(state_case_root).resolve()).as_posix()
+        except ValueError:
+            return Path(input_file).name
+
+    conversions = [f for f in input_files if not (args.skip_existing and markdown_is_reusable(f))]
+    ocr_fallback = set() if mineru_ready else {f for f in conversions if needs_ocr(f)}
+    reconverted_with_ocr = {f for f in conversions if mineru_ready and converted_without_ocr(f)}
+
+    if ocr_fallback and args.engine == "auto" and args.ocr_missing == "ask":
+        files = sorted(case_relative_name(f) for f in ocr_fallback)
+        print(f"OCR_REQUIRED:{json.dumps({'files': files}, ensure_ascii=False)}", flush=True)
+        return EXIT_OCR_REQUIRED
+
+    scan_needed = bool(reconverted_with_ocr) or any(
         not (args.skip_existing and source_is_anonymized(anonymization_state, f, state_case_root))
         for f in input_files
     )
@@ -1899,31 +1945,38 @@ def run_pipeline(resources: PipelineResources):
         print_progress("CONVERT", i, len(input_files))
         existing_md = markdown_path(input_file)
 
-        state_entry = source_state_entry(anonymization_state, input_file, state_case_root)
-        reusable_markdown = existing_md.exists() and (
-            state_entry is None
-            or source_is_converted(anonymization_state, input_file, state_case_root)
-        )
-        if args.skip_existing and reusable_markdown:
+        if input_file not in conversions:
             print(f"📄 [{i}/{len(input_files)}] Already converted, reusing: {existing_md.name}")
             md_files.append(str(existing_md))
             md_sources[str(existing_md)] = input_file
-            update_processing_state(state_target, state_case_root, [input_file], "converted")
+            update_processing_state(
+                state_target, state_case_root, [input_file], "converted",
+                ocr_missing=converted_without_ocr(input_file),
+            )
             convert_success_count += 1
             print()
             continue
 
         print(f"📄 [{i}/{len(input_files)}] Converting: {Path(input_file).name}")
+        without_ocr = input_file in ocr_fallback
+        if without_ocr:
+            print("   ⚠️  Scanned document converted without OCR (MinerU not installed): text layer only")
 
         success, md_path = convert_file(
-            input_file, args.output, engine=args.engine, mode=args.mode, lang=args.lang
+            input_file,
+            args.output,
+            engine="markitdown" if without_ocr else args.engine,
+            mode=args.mode,
+            lang=args.lang,
         )
 
         if success and md_path:
             print(f"   ✅ Markdown generated: {Path(md_path).name}")
             md_files.append(md_path)
             md_sources[md_path] = input_file
-            update_processing_state(state_target, state_case_root, [input_file], "converted")
+            update_processing_state(
+                state_target, state_case_root, [input_file], "converted", ocr_missing=without_ocr
+            )
             convert_success_count += 1
         else:
             print(f"   ❌ Conversion failed, skipping...")
@@ -1948,7 +2001,8 @@ def run_pipeline(resources: PipelineResources):
     pending_scans = [
         md_file
         for md_file in md_files
-        if not (
+        if md_sources[md_file] in reconverted_with_ocr
+        or not (
             args.skip_existing
             and source_is_anonymized(anonymization_state, md_sources[md_file], state_case_root)
         )

package/server/piecemaker/vendor/websocket-server/scripts/mineru_improved_1.py

@@ -5,19 +5,31 @@ Supports both pipeline (direct PDF) and VLM/hybrid (image-based) modes
 """
 
 import argparse
+import importlib.util
 import json
 import os
+import shutil
 import subprocess
 import sys
+import sysconfig
 from pathlib import Path
 
 
-def mineru_executable():
+def find_mineru():
     name = 'mineru.exe' if os.name == 'nt' else 'mineru'
-    sibling = Path(sys.executable).resolve().parent / name
-    if sibling.is_file():
-        return str(sibling)
-    return 'mineru'
+    for directory in (sysconfig.get_path('scripts'), Path(sys.executable).parent, Path(sys.executable).resolve().parent):
+        candidate = Path(directory) / name
+        if candidate.is_file():
+            return str(candidate)
+    return shutil.which(name)
+
+
+def mineru_executable():
+    return find_mineru() or 'mineru'
+
+
+def mineru_available():
+    return importlib.util.find_spec('mineru') is not None and find_mineru() is not None
 
 def parse_with_pipeline(pdf_path, output_dir, lang=None):
     """

package/server/piecemaker/vendor/websocket-server/scripts/smart_converter.py

@@ -24,6 +24,10 @@ import argparse
 import subprocess
 from pathlib import Path
 
+from mineru_improved_1 import mineru_available
+
+IMAGE_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.tiff', '.tif', '.bmp', '.gif'}
+
 # ---------------------------------------------------------------------------
 # Markdown whitespace normalisation
 # ---------------------------------------------------------------------------
@@ -188,6 +192,19 @@ def pdf_has_text_layer(pdf_path):
         return False  # Assume scanned if inspection fails
 
 
+def needs_ocr(file_path):
+    ext = Path(file_path).suffix.lower()
+    if ext in IMAGE_EXTENSIONS:
+        return True
+    return ext == '.pdf' and not pdf_has_text_layer(file_path)
+
+
+def ocr_engine(reason):
+    if HAS_MARKITDOWN and not mineru_available():
+        return 'markitdown', f'{reason}, but MinerU is not installed — text layer only'
+    return 'mineru', reason
+
+
 def inspect_file(file_path):
     """Determine best conversion engine based on file inspection.
 
@@ -197,8 +214,8 @@ def inspect_file(file_path):
     ext = Path(file_path).suffix.lower()
 
     # Images always need OCR → MinerU
-    if ext in ['.jpg', '.jpeg', '.png', '.tiff', '.tif', '.bmp', '.gif']:
-        return 'mineru', 'Image file requires OCR'
+    if ext in IMAGE_EXTENSIONS:
+        return ocr_engine('Image file requires OCR')
 
     # Office docs have native text → markitdown
     if ext in ['.docx', '.pptx', '.xlsx', '.xls', '.doc', '.ppt']:
@@ -214,7 +231,7 @@ def inspect_file(file_path):
         if pdf_has_text_layer(file_path):
             return 'markitdown', 'PDF has extractable text layer'
         else:
-            return 'mineru', 'Scanned PDF requires OCR (no text layer)'
+            return ocr_engine('Scanned PDF requires OCR (no text layer)')
 
     # HTML, TXT, etc. — try markitdown
     if ext in ['.html', '.htm', '.txt', '.md', '.csv']:

package/dist/assets/channel-LQJzz1dz.js

@@ -1 +0,0 @@
-import{U as a,Q as n}from"./mermaid.core-D2KvaDg4.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/assets/classDiagram-ZZMXUADV-BaS6lPLe.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-TICWLB2K-DQ2F5I7F.js";import{_ as i}from"./mermaid.core-D2KvaDg4.js";import"./chunk-5VM5RSS4-DBpdDz0k.js";import"./chunk-XXDRQBXY-oLFixl7-.js";import"./chunk-POPQ4Y6H-uVCWOMNU.js";import"./chunk-F27PBJKO-npTlDSfn.js";import"./index-KoMJ5vMA.js";import"./vendor-codemirror-CN-sJePf.js";import"./vendor-react-B22wqN3J.js";import"./vendor-xterm-BWUgpGtR.js";var c={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{c as diagram};

package/dist/assets/classDiagram-v2-VYDZK3BY-BaS6lPLe.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-TICWLB2K-DQ2F5I7F.js";import{_ as i}from"./mermaid.core-D2KvaDg4.js";import"./chunk-5VM5RSS4-DBpdDz0k.js";import"./chunk-XXDRQBXY-oLFixl7-.js";import"./chunk-POPQ4Y6H-uVCWOMNU.js";import"./chunk-F27PBJKO-npTlDSfn.js";import"./index-KoMJ5vMA.js";import"./vendor-codemirror-CN-sJePf.js";import"./vendor-react-B22wqN3J.js";import"./vendor-xterm-BWUgpGtR.js";var c={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{c as diagram};