@piecemaker-legal/piecemaker 1.0.6

package/server/piecemaker/vendor/websocket-server/legal-forms.cjs

@@ -0,0 +1,89 @@
+/**
+ * Vocabulaire des formes juridiques de sociétés — miroir JS de `_LEGAL_FORMS`
+ * dans `scripts/scan_utils.py`.
+ *
+ * Depuis le choix du cabinet, une société dont le nom porte un sigle est codée
+ * avec ce sigle en préfixe : `SA_1`, `SARL_1`, `SCI_1`, `GMBH_1`, `LLC_1`,
+ * `LTD_1`… Sans sigle, elle tombe sur `PERS_MORALE_1`. Le pipeline Python
+ * (`convert_and_scan_pipeline.py`) et l'administration (`originals-pipeline.cjs`)
+ * écrivent le même mapping : ils doivent partager ce vocabulaire, sinon une
+ * reconstruction admin dédoublerait une entité déjà codée par le CLI.
+ *
+ * Ce module ne sert qu'à *classer* un code déjà attribué (à quelle famille
+ * appartient `SA_1` ?) et à retrouver sa clé de compteur. La *détection* du sigle
+ * dans le texte reste côté Python (scan_utils.extract_legal_form) : c'est elle qui
+ * type l'entité `ORGANIZATION_<sigle>`, d'où le préfixe du code sort ensuite.
+ *
+ * Toute modification de `_LEGAL_FORMS` (ajout d'un sigle) doit être répercutée ici.
+ */
+
+// Jetons canoniques, tenus synchronisés avec `_LEGAL_FORMS` (scan_utils.py).
+const LEGAL_FORM_TOKENS = new Set([
+  // France — exercice libéral / commercial / civil / coopératif / agricole
+  'SELARL', 'SELAS', 'SELCA', 'SELCS', 'SASU', 'SARL', 'EURL', 'EARL',
+  'SCOP', 'SCIC', 'GAEC', 'SAS', 'SCI', 'SCA', 'SCS', 'SCP', 'SCM', 'SNC',
+  'GIE', 'SLP', 'SEL', 'SEM',
+  // Royaume-Uni
+  'EEIG', 'CIC', 'CIO', 'CLG', 'RTM', 'PLC', 'LTD',
+  // États-Unis
+  'LLLP', 'PLLC', 'LLC', 'LLP', 'INC', 'CORP', 'LP', 'GP', 'PC', 'PA', 'CO',
+  // Allemagne
+  'PARTG', 'GMBH', 'KGAA', 'OHG', 'GBR', 'KG', 'AG', 'UG', 'EG', 'EK',
+  // Autres formes européennes / internationales
+  'SE', 'SA', 'BV', 'NV', 'SPA', 'SRL', 'SL', 'LDA', 'AB', 'OY', 'APS', 'AS',
+  'PTYLTD', 'PVTLTD',
+]);
+
+/**
+ * Clé de compteur d'un code société (le sigle), legacy compris. Miroir de
+ * `_societe_counter_key_of_code` (Python). On lit le dernier segment avant le
+ * numéro — sauf présence de MORALE, qui signe le repli sans sigle.
+ *   SA_3 → 'SA' ; URGOT SA → 'SA' ; CLIENT_DEMANDEUR_SA_1 → 'SA' ;
+ *   PERS_MORALE_2 / PERSONNE_MORALE_01 → 'PERS_MORALE'.
+ */
+function societeCounterKey(code) {
+  const tokens = String(code || '')
+    .replace(/_\d+$/, '')
+    .toUpperCase()
+    .split('_')
+    .filter(Boolean);
+  if (tokens.includes('MORALE')) return 'PERS_MORALE';
+  return tokens.length ? tokens[tokens.length - 1] : 'PERS_MORALE';
+}
+
+/**
+ * Un code désigne-t-il une société ? Vrai pour le repli (`…MORALE…`), le legacy
+ * (`SOCIETE_…`) et tout code dont un segment est un sigle connu (`SA_1`,
+ * `CLIENT_DEMANDEUR_GMBH_2`). Les familles distinctives (personne, adresse,
+ * siren, e-mail…) ne portent aucun sigle : à tester après elles pour lever toute
+ * ambiguïté.
+ */
+function isSocieteCode(code) {
+  const normalized = String(code || '').replace(/\s+/g, '_').toUpperCase();
+  if (/(^|_)(AVOCAT|PHYSIQUE|DIRIGEANT)(_|$)/.test(normalized)) return false;
+  if (normalized.includes('MORALE') || normalized.includes('SOCIETE')) return true;
+  const tokens = normalized
+    .replace(/_\d+$/, '')
+    .split('_')
+    .filter(Boolean);
+  if (tokens.some((token) => LEGAL_FORM_TOKENS.has(token))) return true;
+  return /^(CLIENT|ADVERSAIRE)_/.test(normalized) && !tokens.includes('PHYSIQUE');
+}
+
+/**
+ * Sigle porté par un nom de société, lu comme un jeton entier (avec ou sans
+ * points : « SARL », « S.A.R.L. »), sinon null. Heuristique volontairement légère,
+ * pour les chemins qui n'ont pas la détection fine de scan_utils (analyse Ollama) :
+ * la vraie détection dans le texte reste côté Python. Balaye de la fin vers le
+ * début — le sigle suit le plus souvent le nom (« Dupont SARL »).
+ */
+function detectCompanySigle(name) {
+  const tokens = String(name || '').trim().split(/\s+/).filter(Boolean);
+  for (let i = tokens.length - 1; i >= 0; i -= 1) {
+    const token = tokens[i].replace(/[.’',&]/g, '').toUpperCase();
+    if (LEGAL_FORM_TOKENS.has(token)) return token;
+  }
+  return null;
+}
+
+module.exports = { LEGAL_FORM_TOKENS, societeCounterKey, isSocieteCode, detectCompanySigle };

package/server/piecemaker/vendor/websocket-server/lib/doc-generate.cjs

@@ -0,0 +1,229 @@
+/**
+ * Rendu d'un export PieceMaker (HTML produit par `export-render.cjs`) en PDF
+ * ou DOCX — chronologie, feuille de temps.
+ *
+ * À ne pas confondre avec `office-to-pdf.cjs` (`convertToPdf`), qui convertit
+ * les PIÈCES DU CLIENT (.xlsx, .doc, .ppt, .rtf, .odt) avant tamponnage.
+ * Là-bas, LibreOffice est obligatoire et le reste : pandoc *re-compose* le
+ * document (il perd largeurs de colonnes, fusions, zones d'impression), là où
+ * LibreOffice le *reproduit* — et pour une pièce versée aux débats, la
+ * fidélité à ce que le client voit à l'écran est l'objet même du tamponnage.
+ * NE PAS brancher le tamponnage sur ce module.
+ *
+ * Ici c'est l'inverse : le HTML est produit par PieceMaker lui-même, pas
+ * apporté par le client. pandoc y est meilleur — vrais styles Word natifs,
+ * PDF composé par typst (rapide, pas de profil LibreOffice jetable à créer/
+ * détruire à chaque export) — quand il est disponible. Le repli LibreOffice
+ * (`officeToPdf`) reste le comportement actuel pour les postes qui n'ont pas
+ * pandoc : aucune régression n'est acceptable sur ce chemin.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const JSZip = require('jszip');
+
+const { execFilePromise, officeToPdf } = require('./office-to-pdf.cjs');
+
+// Pas d'équivalent de `SOFFICE_HINT` ici, et c'est volontaire : ce message
+// existe là-bas parce que `officeToPdf` LÈVE quand LibreOffice manque. Ici,
+// l'absence de pandoc ou de typst ne produit jamais d'erreur — elle change
+// seulement de chaîne. Un message d'installation n'aurait donc aucun endroit
+// où s'afficher ; c'est l'étape `installer/steps/10-pandoc.mjs` qui le porte.
+
+/** Sonde un binaire selon la même logique que `findSoffice` : variable
+ * d'environnement, chemins usuels, puis nom nu sondé par `--version`. */
+function findBinary(candidates) {
+  for (const candidate of candidates.filter(Boolean)) {
+    const isPathLike = candidate.includes('/') || candidate.includes('\\');
+    if (isPathLike) {
+      if (fs.existsSync(candidate)) return candidate;
+      continue;
+    }
+    const probe = spawnSync(candidate, ['--version'], { encoding: 'utf8', timeout: 30000 });
+    if (probe.status === 0) return candidate;
+  }
+  return null;
+}
+
+function findPandoc() {
+  return findBinary([
+    process.env.PANDOC_PATH,
+    '/opt/homebrew/bin/pandoc',
+    '/usr/local/bin/pandoc',
+    'C:\\Program Files\\Pandoc\\pandoc.exe',
+    'pandoc',
+  ]);
+}
+
+function findTypst() {
+  return findBinary([
+    process.env.TYPST_PATH,
+    '/opt/homebrew/bin/typst',
+    '/usr/local/bin/typst',
+    'typst',
+  ]);
+}
+
+/**
+ * Choix de chaîne, PUR (aucun accès disque/process) : `pandoc`/`typst` sont
+ * les valeurs déjà résolues par `findPandoc`/`findTypst` (chemin ou falsy).
+ */
+function chooseChain({ pandoc, typst, format }) {
+  if (format === 'docx') return pandoc ? 'pandoc' : 'soffice';
+  if (format === 'pdf') {
+    if (pandoc && typst) return 'pandoc-typst';
+    if (pandoc) return 'pandoc-soffice';
+    return 'soffice';
+  }
+  throw new Error(`Format d'export inconnu : ${format}`);
+}
+
+/**
+ * Le lecteur HTML de pandoc jette intégralement le CSS : le `@page { size:
+ * A4; margin: 2cm }` du gabarit (`export-render.cjs`) n'atteint donc jamais
+ * typst. La mise en page passe forcément par ces métadonnées, consommées via
+ * `--metadata-file` plutôt que `-V margin:x=...` (syntaxe ambiguë : x/y au
+ * même niveau que les autres clés prête à confusion). Clés du gabarit typst
+ * par défaut de pandoc 3.8 (`pandoc --print-default-template=typst`).
+ */
+function metadataYaml() {
+  return `papersize: a4
+margin:
+  x: 2cm
+  y: 2cm
+lang: fr
+fontsize: 10pt
+page-numbering: "1"
+`;
+}
+
+/**
+ * Force chaque section Word en A4 portrait avec des marges de 2 cm. Le writer
+ * DOCX de pandoc n'applique pas les métadonnées `papersize`/`margin` (elles
+ * servent au gabarit typst) et son document de référence par défaut est en
+ * Letter. La correction se fait donc directement dans `word/document.xml`,
+ * sans dépendre de LibreOffice ni du poste utilisateur.
+ */
+function applyA4PageLayoutXml(xml) {
+  return String(xml || '').replace(/<w:sectPr\b[^>]*>[\s\S]*?<\/w:sectPr>/g, (section) => {
+    const pageSize = '<w:pgSz w:w="11906" w:h="16838"/>';
+    const pageMargins = '<w:pgMar w:top="1134" w:right="1134" w:bottom="1134" w:left="1134" w:header="567" w:footer="567" w:gutter="0"/>';
+    let updated = /<w:pgSz\b[^>]*\/>/.test(section)
+      ? section.replace(/<w:pgSz\b[^>]*\/>/, pageSize)
+      : section.replace(/(<w:sectPr\b[^>]*>)/, `$1${pageSize}`);
+    updated = /<w:pgMar\b[^>]*\/>/.test(updated)
+      ? updated.replace(/<w:pgMar\b[^>]*\/>/, pageMargins)
+      : updated.replace(/(<w:pgSz\b[^>]*\/>)/, `$1${pageMargins}`);
+    return updated;
+  });
+}
+
+async function applyA4PageLayout(docxPath) {
+  const zip = await JSZip.loadAsync(fs.readFileSync(docxPath));
+  const documentPart = zip.file('word/document.xml');
+  if (!documentPart) throw new Error('DOCX pandoc invalide : word/document.xml est absent.');
+  const documentXml = await documentPart.async('string');
+  zip.file('word/document.xml', applyA4PageLayoutXml(documentXml));
+  const normalized = await zip.generateAsync({
+    type: 'nodebuffer',
+    compression: 'DEFLATE',
+    compressionOptions: { level: 6 },
+  });
+  fs.writeFileSync(docxPath, normalized);
+}
+
+/**
+ * PURE : ne fait qu'assembler les arguments. `typst`, si fourni, doit être le
+ * CHEMIN RÉSOLU du binaire (pas seulement `'typst'`) — trouvé via
+ * `TYPST_PATH`, il n'est pas forcément sur le PATH que pandoc utilisera.
+ * Jamais de guillemets : `spawn` ne passe pas par un shell (même piège que
+ * `sofficeArgs`, office-to-pdf.cjs:88).
+ *
+ * `--metadata title=` neutralise un doublon vérifié à l'exécution : le gabarit
+ * de `export-render.cjs` porte le titre DEUX fois, dans `<title>` (pour
+ * l'onglet du navigateur et les propriétés du document) et dans le `<h1>` du
+ * corps. pandoc lit le `<title>` comme métadonnée et, en sortie autonome
+ * (toujours le cas en DOCX et en PDF), le compose en tête sous le style
+ * `Title` — juste avant le `<h1>` devenu `Heading1`. Sans ce drapeau, le titre
+ * du document apparaît donc deux fois de suite. On garde le `<h1>` (seul
+ * visible par le repli LibreOffice) et on supprime la métadonnée : le gabarit
+ * typst, lui, teste `#if title != none` et n'imprime alors aucun bloc de titre.
+ */
+function pandocArgs(htmlPath, outPath, { metadataPath, typst } = {}) {
+  const ext = path.extname(outPath).toLowerCase();
+  const sansTitreDouble = ['--metadata', 'title='];
+  if (ext === '.docx') {
+    return ['--from=html', '--to=docx', ...sansTitreDouble, '--metadata-file', metadataPath, '--output', outPath, htmlPath];
+  }
+  if (ext === '.pdf') {
+    const args = ['--from=html', '--to=pdf'];
+    if (typst) args.push(`--pdf-engine=${typst}`);
+    args.push(...sansTitreDouble, '--metadata-file', metadataPath, '--output', outPath, htmlPath);
+    return args;
+  }
+  throw new Error(`Extension de sortie non prise en charge pour pandoc : ${ext}`);
+}
+
+/**
+ * Rend `html` en PDF ou DOCX dans `workDir`.
+ * @returns {Promise<{path: string, engine: string}>}
+ */
+async function generateDocument(html, workDir, { format = 'pdf', timeout = 120000 } = {}) {
+  if (format !== 'pdf' && format !== 'docx') {
+    throw new Error(`Format d'export inconnu : ${format} (attendu 'pdf' ou 'docx')`);
+  }
+
+  fs.mkdirSync(workDir, { recursive: true });
+  const htmlPath = path.join(workDir, 'export.html');
+  fs.writeFileSync(htmlPath, html, 'utf8');
+
+  const pandoc = findPandoc();
+  const typst = findTypst();
+  const chain = chooseChain({ pandoc, typst, format });
+
+  if (chain === 'soffice') {
+    const pdfPath = await officeToPdf(htmlPath, workDir, { format, timeout });
+    return { path: pdfPath, engine: 'libreoffice' };
+  }
+
+  // Chaînes pandoc : le fichier de métadonnées est requis dans les deux cas.
+  const metadataPath = path.join(workDir, 'export-meta.yaml');
+  fs.writeFileSync(metadataPath, metadataYaml(), 'utf8');
+
+  if (chain === 'pandoc-soffice') {
+    const docxPath = path.join(workDir, 'export.docx');
+    await runPandoc(pandoc, pandocArgs(htmlPath, docxPath, { metadataPath }), timeout);
+    await applyA4PageLayout(docxPath);
+    const pdfPath = await officeToPdf(docxPath, workDir, { format: 'pdf', timeout });
+    return { path: pdfPath, engine: 'pandoc+libreoffice' };
+  }
+
+  // 'pandoc' (docx direct) ou 'pandoc-typst' (pdf via typst)
+  const outPath = path.join(workDir, `export.${format}`);
+  await runPandoc(pandoc, pandocArgs(htmlPath, outPath, { metadataPath, typst }), timeout);
+  if (format === 'docx') await applyA4PageLayout(outPath);
+  return { path: outPath, engine: chain === 'pandoc-typst' ? 'pandoc+typst' : 'pandoc' };
+}
+
+/** Lance pandoc et lève en français avec stderr si la conversion échoue — un
+ * pandoc présent qui échoue est un vrai bug, on NE retombe PAS sur LibreOffice
+ * ici (le choix de chaîne s'est déjà fait, en amont, sur la présence des
+ * binaires). */
+async function runPandoc(pandoc, args, timeout) {
+  const result = await execFilePromise(pandoc, args, { timeout });
+  if (result.status === 0) return;
+  const detail = (result.stderr || result.stdout || '').trim()
+    || (result.timedOut ? `interrompu après ${Math.round(timeout / 1000)} s` : `code ${result.status}`);
+  throw new Error(`Conversion pandoc échouée (${detail})`);
+}
+
+module.exports = {
+  findPandoc,
+  findTypst,
+  chooseChain,
+  pandocArgs,
+  metadataYaml,
+  applyA4PageLayoutXml,
+  generateDocument,
+};