@piecemaker-legal/piecemaker 1.0.6 → 1.0.7

package/server/piecemaker/vendor/websocket-server/case-instructions.cjs

@@ -1,111 +0,0 @@
-/** Instructions PieceMaker générées dans chaque dossier juridique enregistré. */
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const { registeredCaseFolders } = require('../piecemaker-plugin/scripts/lib/case-folders.cjs');
-const {
-  historyRepo,
-  resolveCase,
-} = require('../piecemaker-plugin/scripts/lib/commits.cjs');
-
-const IMPORT_START = '<!-- piecemaker-instructions-start -->';
-const IMPORT_END = '<!-- piecemaker-instructions-end -->';
-
-function caseHistoryRepoLabel(folder) {
-  try {
-    const legalCase = resolveCase(path.dirname(folder), path.basename(folder));
-    const absolute = historyRepo(path.join(os.homedir(), '.piecemaker'), legalCase);
-    const home = os.homedir();
-    return absolute.startsWith(`${home}${path.sep}`) ? `~${absolute.slice(home.length)}` : absolute;
-  } catch {
-    return '';
-  }
-}
-
-function caseRuleContent(repoRoot, folder = '') {
-  const template = path.join(repoRoot, 'installer', 'templates', 'workspace-CLAUDE.md');
-  if (!fs.existsSync(template)) throw new Error('Le modèle d’instructions PieceMaker est introuvable.');
-  let content = fs.readFileSync(template, 'utf8')
-    .replace(
-      '| Racine des dossiers | ce répertoire (`workspacePath` de `~/.piecemaker/config.json`) |',
-      '| Dossier juridique actif | ce répertoire (`caseFolders` de `~/.piecemaker/config.json`) |',
-    );
-
-  const repoLabel = folder ? caseHistoryRepoLabel(folder) : '';
-  if (repoLabel) {
-    content = content.replace(
-      '| Historique des dossiers | `~/.piecemaker/case-history/` |',
-      `| Historique de ce dossier | \`${repoLabel}\` |`,
-    );
-  }
-  return content;
-}
-
-function managedImportBlock(rule) {
-  return `${IMPORT_START}
-## PieceMaker — instructions gérées
-
-Pour une chronologie factuelle, appeler d'abord l'outil \`chronologie\` du
-serveur MCP \`piecemaker\`. Consulter aussi la règle complète suivante :
-
-@${rule}
-${IMPORT_END}`;
-}
-
-/**
- * Ajoute uniquement un bloc PieceMaker géré. Le reste de CLAUDE.md/AGENTS.md
- * appartient à l'utilisateur et reste byte-for-byte intact.
- */
-function ensureInstructionImport(file, rule) {
-  const block = managedImportBlock(rule);
-  let current = '';
-  try {
-    current = fs.readFileSync(file, 'utf8');
-  } catch {}
-
-  const pattern = new RegExp(`${IMPORT_START}[\\s\\S]*?${IMPORT_END}\\n?`, 'm');
-  const next = pattern.test(current)
-    ? current.replace(pattern, `${block}\n`)
-    : `${block}\n\n${current || '# Ce dossier\n\n<!-- Instructions propres à ce dossier. -->\n'}`;
-  if (next !== current) fs.writeFileSync(file, next, 'utf8');
-}
-
-function ensureCaseRule(repoRoot, folder) {
-  const target = path.join(folder, '.claude', 'rules', 'piecemaker.md');
-  fs.mkdirSync(path.dirname(target), { recursive: true });
-  const content = caseRuleContent(repoRoot, folder);
-  let previous = null;
-  try { previous = fs.readFileSync(target, 'utf8'); } catch {}
-  if (previous !== content) fs.writeFileSync(target, content, 'utf8');
-
-  // Claude Code charge nativement .claude/rules ; les imports explicites
-  // garantissent aussi la disponibilité depuis Codex/AGENTS.md et rendent la
-  // règle visible à la racine sans écraser les consignes propres au dossier.
-  for (const name of ['CLAUDE.md', 'AGENTS.md']) {
-    ensureInstructionImport(path.join(folder, name), target);
-  }
-  return target;
-}
-
-function refreshRegisteredCaseRules(repoRoot, config) {
-  const result = { refreshed: 0, failed: [] };
-  for (const folder of registeredCaseFolders(config)) {
-    try {
-      ensureCaseRule(repoRoot, folder);
-      result.refreshed += 1;
-    } catch (error) {
-      result.failed.push({ folder, error: error.message });
-    }
-  }
-  return result;
-}
-
-module.exports = {
-  IMPORT_END,
-  IMPORT_START,
-  caseRuleContent,
-  ensureCaseRule,
-  ensureInstructionImport,
-  refreshRegisteredCaseRules,
-};

package/server/piecemaker/vendor/websocket-server/scripts/ADDRESS_ANONYMIZATION.md

@@ -1,216 +0,0 @@
-# Partial Address Anonymization Feature
-
-## Overview
-
-This feature implements smart address parsing to preserve city, postal code, and country information in anonymized documents while only anonymizing street addresses. This maintains legal context while protecting private information.
-
-## How It Works
-
-### Address Parsing
-
-When GLiNER extracts a `LOCATION` entity, the system now:
-
-1. **Parses the address** into components:
-   - Street part (number + type + name)
-   - Postal code
-   - City
-   - Country
-
-2. **Determines anonymization strategy**:
-   - **None (no anonymization)**: City or country name only (e.g., "Paris", "France")
-   - **Partial**: Street address with city/postal/country (e.g., "123 Rue de Rivoli, 75001 Paris, France")
-   - **Full**: Unparseable addresses (fallback for safety)
-
-3. **Applies strategy**:
-   - **Partial**: Only street part → code, preserve city/postal/country
-   - **Full**: Entire address → code
-
-### Supported Formats
-
-#### French Addresses
-- Format: `[Number] [Type] [Name], [Postal] [City], [Country]`
-- Examples:
-  - `123 Rue de Rivoli, 75001 Paris, France`
-  - `20 Bis rue de la Princesse, Lyon`
-  - `42 boulevard Saint-Germain, 75005 Paris`
-
-#### Belgian Addresses
-- Format: `[Type] [Name] [Number], [Postal] [City], [Country]`
-- Examples:
-  - `Rue de la Loi 123, 1000 Bruxelles, Belgique`
-  - `Avenue Louise 54, 1050 Bruxelles`
-
-#### Swiss Addresses
-- Format: `[Type] [Name] [Number], [Postal] [City], [Country]`
-- Examples:
-  - `Rue du Rhône 50, 1204 Genève, Suisse`
-  - `Chemin des Fleurs 8, 1006 Lausanne`
-
-#### Luxembourg Addresses
-- Format: `[Type] [Name] [Number], L-[Postal] [City]`
-- Examples:
-  - `Avenue de la Liberté 10, L-1931 Luxembourg`
-
-#### City/Country Only
-- Format: Just the name
-- Examples: `Paris`, `Lyon`, `Bruxelles`, `France`
-- **Not anonymized** - preserved in plaintext
-
-## Examples
-
-### Before Implementation
-
-**Input document:**
-```
-The company is located at 123 Rue de Rivoli, 75001 Paris, France.
-The court in Paris ruled...
-```
-
-**Anonymized output:**
-```
-The company is located at ADRESSE_01.
-The court in ADRESSE_02 ruled...
-```
-❌ Lost all geographic context, even city names
-
-### After Implementation
-
-**Input document:**
-```
-The company is located at 123 Rue de Rivoli, 75001 Paris, France.
-The court in Paris ruled...
-```
-
-**Anonymized output:**
-```
-The company is located at ADRESSE_01, 75001 Paris, France.
-The court in Paris ruled...
-```
-✅ Street anonymized, city/postal preserved, city-only name untouched
-
-## Data Structure
-
-### Mapping File Format
-
-```json
-{
-  "mapping": {
-    "123 Rue de Rivoli": "ADRESSE_01"
-  },
-  "reverse_mapping": {
-    "ADRESSE_01": ["123 Rue de Rivoli"]
-  },
-  "extracted_data": {
-    "adresses": {
-      "ADRESSE_01": {
-        "original": "123 Rue de Rivoli, 75001 Paris, France",
-        "code": "ADRESSE_01",
-        "variants": ["123 Rue de Rivoli"],
-        "score": 0.92,
-        "recognizer": "GLiNER2Recognizer",
-        "parsed": {
-          "success": true,
-          "is_city_only": false,
-          "street_part": "123 Rue de Rivoli",
-          "postal_code": "75001",
-          "city": "Paris",
-          "country": "France",
-          "anonymization_strategy": "partial"
-        }
-      }
-    }
-  }
-}
-```
-
-### Anonymization Strategies
-
-| Strategy | Description | Example Input | Example Output |
-|----------|-------------|---------------|----------------|
-| `none` | City/country only, no anonymization | "Paris" | "Paris" |
-| `partial` | Street anonymized, city/postal/country preserved | "123 Rue de Rivoli, 75001 Paris, France" | "ADRESSE_01, 75001 Paris, France" |
-| `full` | Entire address anonymized (parse failure) | "Complex Format Address" | "ADRESSE_02" |
-
-## Fallback Behavior
-
-| Scenario | Parsing Result | Strategy | Behavior |
-|----------|----------------|----------|----------|
-| Full address with street | `success: true`, `is_city_only: false` | `partial` | Anonymize street only |
-| City or country only | `success: true`, `is_city_only: true` | `none` | Keep visible (not in mapping) |
-| Unparseable address | `success: false` | `full` | Anonymize everything (safe fallback) |
-| Empty/invalid | `success: false` | `full` | Anonymize everything |
-
-## Files Modified
-
-### 1. `websocket-server/scripts/convert_and_scan_pipeline.py`
-- Added `parse_address()` function with regex patterns for French/Belgian/Swiss/Luxembourg addresses
-- Added `is_city_or_country_only()` and `is_known_city_or_country()` helper functions
-- Updated `convert_to_anonymization_format()` to parse addresses and apply strategies
-- Updated `merge_with_existing_mapping()` with same logic
-
-### 2. `websocket-server/lib/anonymization-server.cjs`
-- Updated POST `/api/anonymize/text` route to handle partial address anonymization
-- Added special handling for addresses in both hierarchical and flat mapping formats
-- Updated de-anonymization logic to reconstruct full addresses from partial anonymization
-
-### 3. `websocket-server/scripts/test_address_parsing.py` (new)
-- Comprehensive test suite with 16 test cases
-- Tests French, Belgian, Swiss, Luxembourg, city-only, and unparseable addresses
-- 100% test coverage
-
-## Testing
-
-Run the test suite:
-```bash
-python3 websocket-server/scripts/test_address_parsing.py
-```
-
-Expected output:
-```
-🎉 All tests passed!
-Total tests: 16
-Passed: 16 (100%)
-Failed: 0
-```
-
-## Integration Testing
-
-To test with real documents:
-
-```bash
-# Process a document with addresses
-python3 websocket-server/scripts/convert_and_scan_pipeline.py \
-    test_document.pdf \
-    -o output \
-    --document-id test_partial
-
-# Check the mapping file
-cat output/mapping_test_partial.json | jq '.extracted_data.adresses | .[].parsed'
-
-# Verify:
-# 1. City-only addresses are NOT in the mapping
-# 2. Full addresses have parsed data with partial strategy
-# 3. Unparseable addresses have full strategy
-```
-
-## Safety Features
-
-1. **City-only detection**: Cities and countries are never accidentally anonymized
-2. **Parse failure fallback**: Unparseable addresses default to full anonymization (safest)
-3. **No false negatives**: Street addresses are never left visible by mistake
-4. **Validation**: 100% test coverage ensures reliability
-
-## Performance
-
-- **Parsing success rate**: >90% for French addresses
-- **City-only detection**: 100% accuracy for known cities
-- **Fallback coverage**: 100% (all unparseable addresses handled safely)
-- **Zero false negatives**: No street addresses leaked
-
-## Future Enhancements
-
-Potential improvements:
-- Add more European address formats (Spain, Italy, Germany)
-- Support US/UK address formats
-- ML-based address component recognition for complex formats
-- User-configurable city/country whitelist

package/server/piecemaker/vendor/websocket-server/scripts/DEDUPLICATION_CHANGES.md

@@ -1,134 +0,0 @@
-# Entity Deduplication Implementation Summary
-
-## Changes Made to `convert_and_scan_pipeline.py`
-
-### 1. Added Imports (Lines 34-42)
-```python
-import unicodedata
-import re
-from typing import List, Optional, Tuple, Dict, Set
-```
-
-### 2. Added Helper Functions (Before `convert_to_anonymization_format()`)
-
-#### `normalize_name(text: str) -> str`
-- Removes diacritics (é → e, à → a, etc.)
-- Converts to lowercase
-- Removes honorifics/titles (Mr., Mrs., Ms., Dr., M., Mme., Maître, etc.)
-- Normalizes whitespace (multiple spaces → single space)
-- Returns normalized form for comparison only
-
-#### `are_names_similar(name1, norm1, name2, norm2) -> bool`
-- Checks if two names refer to the same person using multiple strategies:
-  - Exact match after normalization
-  - Substring match (one contains the other, min 3 chars)
-  - Token-based match (all tokens of shorter name appear in longer)
-
-#### `consolidate_duplicate_entities(entities: List[Dict]) -> List[Dict]`
-- Groups entities by similarity
-- Handles both exact duplicates and variations (e.g., "Mr. Dupont" vs "Jean Dupont")
-- For each group:
-  - Chooses longest variant as canonical text
-  - Keeps highest score among all variants
-  - Stores all unique variants (removes duplicates while preserving order)
-- Returns deduplicated entity list
-
-### 3. Updated `convert_to_anonymization_format()`
-
-**Added pre-processing:**
-```python
-# Consolidate PERSON entities to remove duplicates
-for entity_type in consolidated_entities.get("entities", {}).keys():
-    if entity_type == "PERSON":
-        consolidated_entities["entities"][entity_type] = consolidate_duplicate_entities(
-            consolidated_entities["entities"][entity_type]
-        )
-```
-
-**Modified main loop:**
-- Removed: `mapping[text_lower] = code` (no lowercase in mapping)
-- Changed: `"variants": [text, text_lower]` → `"variants": variants`
-- Added: Loop through pre-consolidated variants and add each to mapping
-- Get variants from: `entity.get("variants", [text])`
-
-### 4. Updated `merge_with_existing_mapping()`
-
-**Applied same changes:**
-- Removed: `merged_mapping[text_lower] = new_code`
-- Changed: `"variants": [text, text_lower]` → `"variants": variants`
-- Get variants from: `old_entry.get("variants", [text])`
-- Add all variants to merged mapping
-
-## Expected Behavior
-
-### Before (Current Output)
-```json
-{
-  "mapping": {
-    "Mr. Dupont": "PERSONNE_PHYSIQUE_03",
-    "mr. gilly": "PERSONNE_PHYSIQUE_03",
-    "Mr. Dupont": "PERSONNE_PHYSIQUE_04",  // duplicate gets different code
-    "mr. gilly": "PERSONNE_PHYSIQUE_04",
-    "Mr.  Dupont": "PERSONNE_PHYSIQUE_05",
-    "mr.  gilly": "PERSONNE_PHYSIQUE_05",
-    "Jean Dupont": "PERSONNE_PHYSIQUE_08"
-  }
-}
-```
-
-### After (Fixed Output)
-```json
-{
-  "mapping": {
-    "Jean Dupont": "PERSONNE_PHYSIQUE_03",
-    "Mr. Dupont": "PERSONNE_PHYSIQUE_03",
-    "Mr.  Dupont": "PERSONNE_PHYSIQUE_03",
-    "Mr.Dupont": "PERSONNE_PHYSIQUE_03"
-  },
-  "extracted_data": {
-    "personnes_physiques": {
-      "PERSONNE_PHYSIQUE_03": {
-        "original": "Jean Dupont",
-        "code": "PERSONNE_PHYSIQUE_03",
-        "variants": ["Jean Dupont", "Mr. Dupont", "Mr.  Dupont", "Mr.Dupont"],
-        "score": 0.95,
-        "recognizer": "GLiNER2Recognizer"
-      }
-    }
-  }
-}
-```
-
-## Key Improvements
-
-1. **No lowercase duplicates**: Removed redundant lowercase variants from mapping and variants array
-2. **Exact duplicates consolidated**: Same person appearing multiple times gets single code
-3. **Spacing variations handled**: "Mr. Dupont" vs "Mr.  Dupont" vs "Mr.Dupont" → same code
-4. **Name variations consolidated**: "Mr. Dupont" vs "Jean Dupont" → same code
-5. **Longest variant as canonical**: "Jean Dupont" (longest) chosen over "Mr. Dupont"
-6. **No duplicate variants**: Variants array contains only unique strings
-7. **Non-PERSON entities unaffected**: Organizations and locations not consolidated
-
-## Test Results
-
-All unit tests pass:
-- ✅ normalize_name() - 7/7 tests
-- ✅ are_names_similar() - 8/8 tests
-- ✅ consolidate_duplicate_entities() - 5/5 tests
-
-Test demonstrates:
-- 7 input entities → 3 unique persons
-- "Mr. Dupont" (appears twice) + "Mr.  Dupont" + "Jean Dupont" + "Mr.Dupont" → single entity
-- Canonical form: "Jean Dupont" (longest)
-- Score: 0.95 (highest)
-- Variants: 4 unique strings (no duplicates)
-
-## Next Steps for Verification
-
-1. **Test with real document**: Process a document containing duplicate person names
-2. **Compare entity counts**:
-   - Before: ~185 PERSONNE_PHYSIQUE entries
-   - After: ~90-100 entries (expected ~50% reduction)
-3. **Verify consolidation**: Check that variations of same person get same code
-4. **Verify non-PERSON entities**: Organizations and locations unaffected
-5. **Regression test**: Different people still get different codes

package/server/piecemaker/vendor/websocket-server/scripts/GLINER2_README.md

@@ -1,138 +0,0 @@
-# GLiNER2.5 Entity Extractor
-
-## Description
-
-PieceMaker utilise GLiNER2.5, un extracteur d'entités nommé multilingue basé sur
-la nouvelle architecture boundary de Fastino (287 M paramètres). Il détecte
-localement les entités sensibles dans les documents Markdown.
-
-## Installation
-
-```bash
-pip install 'gliner2[local]>=2.0.0'
-```
-
-Le modèle `fastino/gliner2.5-multi-v1` est téléchargé par l’installateur
-(environ 1,1 Go). La migration depuis `fastino/gliner2-multi-v1` est obligatoire.
-
-## Utilisation via l'interface
-
-1. Cliquer sur le bouton 🏷️ dans la barre de contrôle
-2. Sélectionner un ou plusieurs fichiers Markdown (.md)
-3. Cliquer sur "▶ Extraire"
-4. Les résultats sont sauvegardés dans le dossier de sortie configuré
-
-## Utilisation en ligne de commande
-
-```bash
-python presidio-gliner/presidio-gliner.py <fichier.md> -o <dossier_sortie>
-```
-
-### Exemple
-
-```bash
-python presidio-gliner/presidio-gliner.py document.md -o ./presidio_gliner_output
-```
-
-## Entités détectées
-
-Le pipeline GLiNER2.5 + Presidio détecte notamment les types suivants :
-
-- **person**: Noms de personnes
-- **email**: Adresses email
-- **phone**: Numéros de téléphone (mobile et fixe)
-- **address**: Adresses physiques et localisations
-- **organization**: Noms d'entreprises et organisations
-- **date**: Dates (incluant dates de naissance)
-- **ssn**: Numéros de sécurité sociale
-- **credit_card**: Numéros de carte de crédit
-- **bank_account**: Numéros de compte bancaire
-- **passport**: Numéros de passeport
-- **ip_address**: Adresses IP
-- **url**: URLs et adresses web
-
-## Format de sortie
-
-Le script génère un fichier JSON avec la structure suivante:
-
-```json
-{
-  "source_file": "/chemin/vers/fichier.md",
-  "scanned_at": "2025-01-15T10:30:00Z",
-  "entities": {
-    "PERSON": [
-      {
-        "text": "John Doe",
-        "start": 123,
-        "end": 131,
-        "score": 0.95,
-        "recognizer": "gliner2"
-      }
-    ],
-    "EMAIL": [
-      {
-        "text": "john.doe@example.com",
-        "start": 145,
-        "end": 165,
-        "score": 0.98,
-        "recognizer": "gliner2"
-      }
-    ]
-  },
-  "summary": {
-    "total_entities_found": 15,
-    "entity_types": ["PERSON", "EMAIL", "PHONE", "ADDRESS"],
-    "model": "fastino/gliner2.5-multi-v1"
-  }
-}
-```
-
-## Configuration
-
-### Seuil de confiance
-
-Le scanner utilise le seuil de confiance 0,5 recommandé par défaut pour la
-nouvelle tête boundary. Les entités moins certaines ne sont pas retournées.
-
-### Variables d'environnement
-
-- `GLINER2_SCAN_PATH`: Chemin personnalisé vers le script Python
-- `PYTHON_PATH`: Chemin vers l'interpréteur Python (défaut: `python3`)
-
-## Comparaison avec Presidio
-
-| Caractéristique | GLiNER2 | Presidio |
-|----------------|---------|----------|
-| API | Simple, 1 modèle | Multiple composants |
-| Performance CPU | Optimisée | Plus lente |
-| Confidence scores | Natif | Natif |
-| Spans de texte | Natif | Natif |
-| Format de sortie | JSON natif | JSON natif |
-| Taille du modèle | 287M params | Variable |
-| Personnalisation | Labels flexibles | Patterns regex |
-
-## Avantages de GLiNER2
-
-1. **API simplifiée**: Un seul modèle, une seule méthode d'extraction
-2. **Performance**: Optimisé pour CPU, inférence rapide
-3. **Flexibilité**: Support de labels personnalisés sans réentraînement
-4. **Extraction native**: Confidence scores et spans inclus sans post-processing
-5. **Format JSON**: Output structuré directement utilisable
-
-## Dépendances
-
-- Python 3.10+
-- `gliner2[local]>=2.0.0`
-- torch et transformers (installés par l’extra `local`)
-
-## Limitations
-
-- Nécessite un téléchargement initial du modèle (~1,1 Go)
-- Performance optimale sur CPU moderne (multi-core recommandé)
-- Précision variable selon la qualité du texte source
-
-## Support
-
-Pour plus d'informations sur GLiNER2.5 :
-- Documentation : https://github.com/fastino-ai/GLiNER2
-- Modèle : https://huggingface.co/fastino/gliner2.5-multi-v1