@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/docx-text-worker.cjs

@@ -0,0 +1,43 @@
+/** Normalisation du texte OOXML hors de la boucle d'événements du serveur. */
+const { parentPort, workerData } = require('node:worker_threads');
+
+function decodeXmlText(value) {
+  return String(value || '').replace(/&(?:#(\d+)|#x([0-9a-f]+)|amp|lt|gt|quot|apos);/gi, (entity, decimal, hexadecimal) => {
+    const codePoint = decimal ? Number(decimal) : Number.parseInt(hexadecimal, 16);
+    if ((decimal || hexadecimal) && Number.isInteger(codePoint) && codePoint >= 0 && codePoint <= 0x10ffff) {
+      return String.fromCodePoint(codePoint);
+    }
+    if (decimal || hexadecimal) return entity;
+    return { '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'" }[entity.toLowerCase()] || entity;
+  });
+}
+
+function wordXmlToText(xml) {
+  const source = String(xml || '')
+    .replace(/<w:(?:del|moveFrom)\b[^>]*>[\s\S]*?<\/w:(?:del|moveFrom)>/gi, '');
+  const tokens = /<w:t\b[^>]*>([\s\S]*?)<\/w:t>|<w:tab\b[^>]*\/?\s*>|<w:br\b[^>]*\/?\s*>|<\/w:p\s*>|<\/w:tc\s*>/gi;
+  let text = '';
+  let match;
+  while ((match = tokens.exec(source))) {
+    if (match[1] !== undefined) text += decodeXmlText(match[1].replace(/<[^>]+>/g, ''));
+    else if (/^<\/w:p/i.test(match[0])) text += '\n';
+    else if (/^<\/w:tc/i.test(match[0]) || /^<w:tab/i.test(match[0])) text += '\t';
+    else text += '\n';
+  }
+  return text
+    .replace(/\r/g, '')
+    .split('\n')
+    .map((line) => line.replace(/[ \t]+$/g, ''))
+    .filter((line, index, lines) => line || (index > 0 && lines[index - 1]))
+    .join('\n')
+    .trim();
+}
+
+const sections = (Array.isArray(workerData) ? workerData : [])
+  .map(({ title, xml }) => ({ title: String(title || ''), content: wordXmlToText(xml) }))
+  .filter((section) => section.content);
+const text = sections.length === 1 && sections[0].title === 'Corps du document'
+  ? sections[0].content
+  : sections.map((section) => `〔${section.title}〕\n${section.content}`).join('\n\n');
+
+parentPort.postMessage(text);

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/hook-io.mjs

@@ -0,0 +1,249 @@
+/**
+ * Shared I/O helpers for PieceMaker Claude Code hooks.
+ *
+ * Contract confirmed against https://code.claude.com/docs/en/hooks:
+ *  - stdin carries one JSON object per invocation. Common fields on every
+ *    event: session_id, transcript_path, cwd, permission_mode,
+ *    hook_event_name (+ prompt_id, agent_id/agent_type when applicable).
+ *  - PreToolUse adds: tool_name, tool_input, tool_use_id.
+ *  - PostToolUse adds: tool_name, tool_input, tool_response, tool_use_id.
+ *  - Stop adds: last_assistant_message, stop_reason.
+ *  - TaskCompleted adds: task_id, task_name, task_status.
+ *  - Exit code 0 + JSON on stdout -> JSON is applied. Exit code 2 -> blocking
+ *    error, stderr shown as the reason, stdout ignored. Any other exit code
+ *    -> non-blocking error, action proceeds, first stderr line surfaced.
+ *  - Never mix "exit code only" and "exit 0 + JSON" signalling.
+ *
+ * Every hook in this plugin fails open: on any internal error, on timeout, or
+ * when nothing relevant applies, it exits 0 with no stdout so the session is
+ * completely unaffected.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const HOME_DIR = path.join(os.homedir(), '.piecemaker');
+export const CONFIG_FILE = path.join(HOME_DIR, 'config.json');
+export const BILLING_DIR = path.join(HOME_DIR, 'billing');
+export const SYNTHESIS_DIR = path.join(BILLING_DIR, 'synthese');
+
+/** Upper bound on waiting for stdout to drain before exiting anyway. */
+const FLUSH_TIMEOUT_MS = 2000;
+
+/**
+ * Read stdin fully as text, tracking whether the stream reached a clean `end`.
+ * Never rejects — resolves with `{ data, complete }`:
+ *  - `data`     : everything collected so far (possibly '').
+ *  - `complete` : true only when the stream ended cleanly (EOF). false on a
+ *                 timeout or a stream error, where `data` may be partial.
+ *
+ * A TTY with nothing piped in resolves `{ data: '', complete: true }`: there is
+ * genuinely no input, which is not a truncation.
+ *
+ * The timeout is only a safety net against a producer that never closes the
+ * pipe. It must be generous enough that a large-but-live payload always reaches
+ * `end` before it fires — a premature timeout that returns partial bytes is the
+ * root cause of the size-dependent leak this guards against.
+ */
+export function readStdinDetailed(timeoutMs = 3000) {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      resolve({ data: '', complete: true });
+      return;
+    }
+    let data = '';
+    let done = false;
+    const finish = (complete) => {
+      if (done) return;
+      done = true;
+      resolve({ data, complete });
+    };
+    const timer = setTimeout(() => finish(false), timeoutMs);
+    try {
+      process.stdin.setEncoding('utf8');
+      process.stdin.on('data', (chunk) => {
+        data += chunk;
+      });
+      process.stdin.on('end', () => {
+        clearTimeout(timer);
+        finish(true);
+      });
+      process.stdin.on('error', () => {
+        clearTimeout(timer);
+        finish(false);
+      });
+    } catch {
+      clearTimeout(timer);
+      finish(false);
+    }
+  });
+}
+
+/**
+ * Read stdin fully as text, bounded by timeoutMs. Never rejects — resolves
+ * with whatever was collected (possibly '') on timeout, error, or a TTY with
+ * nothing piped in (e.g. a manual test run). Thin wrapper over
+ * `readStdinDetailed` that drops the completeness flag, for callers that only
+ * need the text.
+ */
+export async function readStdin(timeoutMs = 3000) {
+  const { data } = await readStdinDetailed(timeoutMs);
+  return data;
+}
+
+/** Parse the hook JSON payload from stdin. Returns null on any failure. */
+export async function readHookPayload(timeoutMs = 3000) {
+  const raw = await readStdin(timeoutMs);
+  if (!raw || !raw.trim()) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Like `readHookPayload`, but never hides a truncated/garbled input as "nothing
+ * to do". Returns `{ payload, raw, complete }`:
+ *  - `payload`  : the parsed object, or null when parsing failed.
+ *  - `raw`      : the exact stdin text (possibly partial).
+ *  - `complete` : true only when the stream reached a clean EOF.
+ *
+ * A hook that guards a privacy boundary must tell apart three cases that
+ * `readHookPayload` collapses into a single `null`:
+ *  1. empty input (TTY / nothing piped)      → raw '' , complete true  → fail open;
+ *  2. a valid, fully-read payload            → payload set             → normal;
+ *  3. non-empty input that will not parse    → payload null, raw set   → fail CLOSED,
+ *     whether because it was cut off mid-stream (`complete` false) or arrived
+ *     whole but malformed (`complete` true).
+ */
+export async function readHookPayloadStrict(timeoutMs = 3000) {
+  const { data: raw, complete } = await readStdinDetailed(timeoutMs);
+  if (!raw || !raw.trim()) return { payload: null, raw: raw || '', complete };
+  try {
+    return { payload: JSON.parse(raw), raw, complete };
+  } catch {
+    return { payload: null, raw, complete };
+  }
+}
+
+/** Load ~/.piecemaker/config.json. Returns {} when absent or invalid. */
+export function loadPieceMakerConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) return {};
+    const parsed = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/** Exit 0 with no stdout — the fast "ignore this event" path. */
+export function noop() {
+  process.exit(0);
+}
+
+/**
+ * Exit 0 and print a JSON hook-output object to stdout.
+ *
+ * The write is awaited before exiting. On a pipe — which is exactly how Claude
+ * Code runs a hook — stdout is asynchronous, and `process.exit()` drops
+ * whatever is still in flight past the 64 KB pipe buffer. A truncated JSON is
+ * unparseable, so the harness can fall back to the original hook result. A
+ * security guard must not depend on payload size.
+ */
+export function emit(output) {
+  let payload;
+  try {
+    if (!output || typeof output !== 'object') {
+      noop();
+      return;
+    }
+    payload = JSON.stringify(output);
+  } catch {
+    // Serialization failure must never block the session.
+    noop();
+    return;
+  }
+
+  // Safety net: an stdout that never drains must not hang the session either.
+  // Unref'd, so a completed write exits immediately instead of waiting it out.
+  const guard = setTimeout(() => process.exit(0), FLUSH_TIMEOUT_MS);
+  guard.unref?.();
+  process.stdout.write(payload, () => {
+    clearTimeout(guard);
+    process.exit(0);
+  });
+}
+
+/**
+ * Run the hook body against a hard timeout. On timeout, a thrown error, or a
+ * falsy/non-object return value, fail open (exit 0, no output). Otherwise the
+ * returned object is emitted as the hook's JSON output.
+ *
+ * Note: this only protects async work (spawned children, timers). Purely
+ * synchronous CPU-bound code blocks the event loop and the timeout cannot
+ * preempt it. That is deliberate for the substitution in mapping.cjs, which has
+ * no size ceiling: a hook that returned early on a large document would hand
+ * the model the original text in clear. The body's promise settles as a
+ * microtask, ahead of the timer's macrotask, so a slow substitution is always
+ * emitted in full — verified against an 8 s synchronous body under a 5 s
+ * timeout. The timeout remains what it was meant for: async work that hangs.
+ */
+export async function runHook(bodyFn, { timeoutMs = 5000 } = {}) {
+  let timer;
+  try {
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => resolve('__timeout__'), timeoutMs);
+    });
+    const result = await Promise.race([bodyFn(), timeout]);
+    clearTimeout(timer);
+    if (result === '__timeout__' || !result || typeof result !== 'object') {
+      noop();
+      return;
+    }
+    emit(result);
+  } catch {
+    clearTimeout(timer);
+    noop();
+  }
+}
+
+/** True when filePath resolves to somewhere under one of roots. */
+export function isUnderAnyRoot(filePath, roots) {
+  if (!filePath) return false;
+  const resolved = path.resolve(filePath);
+  return (roots || []).some((root) => {
+    if (!root) return false;
+    const resolvedRoot = path.resolve(root);
+    return resolved === resolvedRoot || resolved.startsWith(resolvedRoot + path.sep);
+  });
+}
+
+export function hasDocumentExtension(filePath, extensions) {
+  if (!filePath) return false;
+  const ext = path.extname(filePath).toLowerCase();
+  return (extensions || []).includes(ext);
+}
+
+/** mkdir -p that never throws — callers check the return value. */
+export function ensureDirSafe(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Append one line to a JSONL file. Single appendFileSync call, never throws. */
+export function appendJsonl(filePath, obj) {
+  try {
+    ensureDirSafe(path.dirname(filePath));
+    fs.appendFileSync(filePath, `${JSON.stringify(obj)}\n`, 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/institutional-terms.cjs

@@ -0,0 +1,160 @@
+/**
+ * Liste globale des entités institutionnelles à ne jamais anonymiser.
+ *
+ * GLiNER détecte volontiers comme « organisation » des institutions publiques —
+ * juridictions, registres, publications officielles, administrations : « Tribunal
+ * de Commerce », « Cour de cassation », « Registre du Commerce et des Sociétés »,
+ * « BODACC », « RCS »… Ce ne sont pas des données personnelles ; les coder
+ * rendrait un acte de procédure illisible et n'apporte aucune protection.
+ *
+ * On ne débranche pas la détection : GLiNER continue de les trouver. C'est au
+ * moment de bâtir le mapping qu'elles sont écartées — `normalizeMappingDocument`
+ * (mapping.cjs) appelle `isInstitutionalEntity` sur chaque entité, à la lecture
+ * comme à l'écriture. Une entité bannie ne persiste donc jamais dans
+ * `mapping_default.json` et n'est jamais substituée par les hooks.
+ *
+ * La liste est globale (tous dossiers confondus), éditable depuis les paramètres
+ * de l'administration, et la comparaison est insensible à la casse et aux
+ * accents. Un terme correspond dès qu'il apparaît comme groupe de mots complet
+ * dans l'entité : « Tribunal de Commerce » écarte « Tribunal de Commerce de
+ * Nanterre ».
+ *
+ * Le module vit dans le plugin parce que les hooks, distribués seuls, en ont
+ * besoin via `mapping.cjs` et ne peuvent require `websocket-server/`.
+ */
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const STORE_VERSION = 1;
+
+function piecemakerHome() {
+  return process.env.PIECEMAKER_HOME || path.join(os.homedir(), '.piecemaker');
+}
+
+/** Fichier de stockage — global, hors dossier juridique. Surchargeable pour les tests. */
+function institutionalTermsFile() {
+  return process.env.PIECEMAKER_INSTITUTIONAL_TERMS || path.join(piecemakerHome(), 'institutional-terms.json');
+}
+
+function escapeRegex(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** Forme comparable : sans accents, minuscules, apostrophes et espaces unifiés. */
+function normalizeForMatch(value) {
+  return String(value || '')
+    .normalize('NFD')
+    .replace(/[̀-ͯ]/g, '')
+    .toLowerCase()
+    .replace(/['‘’ʼ´`]/g, "'")
+    .replace(/[\s ]+/g, ' ')
+    .trim();
+}
+
+/** Forme d'affichage : espaces normalisés, casse et accents d'origine conservés. */
+function cleanTerm(value) {
+  return String(value || '').replace(/[\s ]+/g, ' ').trim();
+}
+
+/** Termes nettoyés, dédupliqués (insensible casse/accents) et triés. */
+function dedupeTerms(terms) {
+  const seen = new Set();
+  const out = [];
+  for (const raw of Array.isArray(terms) ? terms : []) {
+    const display = cleanTerm(raw);
+    if (!display) continue;
+    const key = normalizeForMatch(display);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push(display);
+  }
+  return out.sort((a, b) => normalizeForMatch(a).localeCompare(normalizeForMatch(b), 'fr'));
+}
+
+function readTermsFrom(file) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(file, 'utf8').replace(/^/, ''));
+    const list = Array.isArray(raw) ? raw : Array.isArray(raw?.terms) ? raw.terms : [];
+    return dedupeTerms(list);
+  } catch {
+    return [];
+  }
+}
+
+/** Liste courante et son emplacement — pour l'API d'administration. */
+function readInstitutionalTerms() {
+  const file = institutionalTermsFile();
+  return { file, terms: readTermsFrom(file) };
+}
+
+/** Enregistre la liste (nettoyée, dédupliquée, triée) et invalide le cache. */
+function writeInstitutionalTerms(terms) {
+  const file = institutionalTermsFile();
+  const clean = dedupeTerms(terms);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const payload = `${JSON.stringify({ version: STORE_VERSION, terms: clean }, null, 2)}\n`;
+  const temporary = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, payload, { encoding: 'utf8', mode: 0o600 });
+  fs.renameSync(temporary, file);
+  cache = null;
+  return { file, terms: clean };
+}
+
+// ── Détection ────────────────────────────────────────────────────────────────
+// `isInstitutionalEntity` est appelé sur chaque entité à chaque lecture de
+// mapping (donc à chaque hook Read) : les regex sont compilées une fois et le
+// cache est invalidé dès que le fichier change (mtime + taille).
+
+let cache = null;
+
+function statSignature(file) {
+  try {
+    const stats = fs.statSync(file);
+    return `${stats.mtimeMs}:${stats.size}`;
+  } catch {
+    return 'absent';
+  }
+}
+
+function compileMatchers(terms) {
+  const matchers = [];
+  for (const term of terms) {
+    const normalized = normalizeForMatch(term);
+    if (!normalized) continue;
+    const body = normalized.split(' ').map(escapeRegex).join('\\s+');
+    // Le terme doit former un groupe de mots complet dans l'entité, jamais un
+    // fragment collé à d'autres lettres/chiffres.
+    matchers.push(new RegExp(`(?<![\\p{L}\\p{N}])${body}(?![\\p{L}\\p{N}])`, 'u'));
+  }
+  return matchers;
+}
+
+function currentMatchers() {
+  const file = institutionalTermsFile();
+  const key = `${file}#${statSignature(file)}`;
+  if (!cache || cache.key !== key) {
+    const terms = readTermsFrom(file);
+    cache = { key, terms, matchers: compileMatchers(terms) };
+  }
+  return cache;
+}
+
+/** Vrai si `entity` contient un terme institutionnel banni (casse/accents ignorés). */
+function isInstitutionalEntity(entity) {
+  const { matchers } = currentMatchers();
+  if (!matchers.length) return false;
+  const normalized = normalizeForMatch(entity);
+  if (!normalized) return false;
+  return matchers.some((regex) => regex.test(normalized));
+}
+
+module.exports = {
+  cleanTerm,
+  dedupeTerms,
+  institutionalTermsFile,
+  isInstitutionalEntity,
+  normalizeForMatch,
+  readInstitutionalTerms,
+  writeInstitutionalTerms,
+};

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/legifrance-reads.cjs

@@ -0,0 +1,85 @@
+'use strict';
+
+/**
+ * Traçage déterministe des lectures dans un dossier de résultats Legifrance.
+ *
+ * L'outil MCP `Download_Query_Results` dépose un marqueur `.legifrance-results.json`
+ * à la racine du dossier qu'il crée. Le hook `track-legifrance-reads.mjs` appelle
+ * ces helpers à chaque `Read` : si le fichier lu est sous un tel dossier, la
+ * lecture est enregistrée dans `.read-log.json` à la racine du dossier — un
+ * journal purement mécanique de ce que l'agent de tri (Haiku) a réellement
+ * ouvert. Aucun LLM, aucune analyse : juste un compteur.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const MARKER_NAME = '.legifrance-results.json';
+const READ_LOG_NAME = '.read-log.json';
+// Fichiers internes au dossier que l'on ne trace pas (bruit).
+const IGNORED = new Set([MARKER_NAME, READ_LOG_NAME]);
+
+/**
+ * Remonte depuis le fichier lu jusqu'à trouver la racine d'un dossier de
+ * résultats (celle qui porte le marqueur). Borné pour ne jamais balayer tout
+ * le disque. Renvoie le chemin absolu de la racine, ou null.
+ */
+function findResultsRoot(absoluteFilePath, { maxDepth = 8 } = {}) {
+  if (!absoluteFilePath) return null;
+  let dir = path.dirname(path.resolve(absoluteFilePath));
+  for (let i = 0; i < maxDepth; i += 1) {
+    try {
+      if (fs.existsSync(path.join(dir, MARKER_NAME))) return dir;
+    } catch {
+      return null;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break; // racine du système
+    dir = parent;
+  }
+  return null;
+}
+
+function loadReadLog(root) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(root, READ_LOG_NAME), 'utf8'));
+  } catch {
+    return { kind: 'legifrance-read-log', reads: [], counts: {}, distinct: 0 };
+  }
+}
+
+/**
+ * Enregistre une lecture. `relFile` est le chemin du fichier lu, relatif à la
+ * racine du dossier. Renvoie le journal mis à jour (aussi écrit sur disque).
+ * Ne trace pas le marqueur ni le journal lui-même.
+ */
+function recordRead(root, relFile, meta = {}) {
+  const normalized = relFile.split(path.sep).join('/');
+  if (IGNORED.has(normalized)) return null;
+
+  const log = loadReadLog(root);
+  if (!log.counts) log.counts = {};
+  if (!Array.isArray(log.reads)) log.reads = [];
+
+  const firstTime = !(normalized in log.counts);
+  log.counts[normalized] = (log.counts[normalized] || 0) + 1;
+  log.reads.push({
+    file: normalized,
+    at: meta.at || new Date().toISOString(),
+    ...(meta.sessionId ? { session: meta.sessionId } : {}),
+    ...(meta.toolUseId ? { tool_use_id: meta.toolUseId } : {}),
+  });
+  log.distinct = Object.keys(log.counts).length;
+  log.updated = meta.at || new Date().toISOString();
+
+  fs.writeFileSync(path.join(root, READ_LOG_NAME), `${JSON.stringify(log, null, 2)}\n`, 'utf8');
+  return { log, firstTime };
+}
+
+module.exports = {
+  MARKER_NAME,
+  READ_LOG_NAME,
+  findResultsRoot,
+  loadReadLog,
+  recordRead,
+};