@piecemaker-legal/piecemaker 2.0.10 → 2.0.12

package/server/piecemaker/vendor/installer/steps/02-dependances-node.mjs

@@ -9,7 +9,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { log, spinner, columns } from '../lib/ui.mjs';
-import { run, npmBin, npmEnv, REPO_ROOT } from '../lib/platform.mjs';
+import { run, npmBin, npmEnv, GIT_REPO_ROOT } from '../lib/platform.mjs';
 
 export const meta = {
   id: '02-dependances-node',
@@ -36,7 +36,7 @@ function readPackageJson(dir) {
 // Certaines distributions npm conservent spawn-helper de node-pty en 0644.
 // Le module se charge alors normalement mais tout pty.spawn échoue avec
 // « posix_spawnp failed ». Réparer le bit exécutable est idempotent.
-export function repairNodePtySpawnHelpers(repoRoot = REPO_ROOT, { repair = true } = {}) {
+export function repairNodePtySpawnHelpers(repoRoot = GIT_REPO_ROOT, { repair = true } = {}) {
   if (process.platform === 'win32') return { found: 0, repaired: 0, ready: true };
   const prebuilds = path.join(repoRoot, 'node_modules', 'node-pty', 'prebuilds');
   if (!fs.existsSync(prebuilds)) return { found: 0, repaired: 0, ready: false };
@@ -88,7 +88,7 @@ async function npmInstall(dir, label, ctx) {
 export async function install(ctx) {
   const results = [];
 
-  results.push(['racine du projet', await npmInstall(REPO_ROOT, 'Racine', ctx)]);
+  results.push(['racine du projet', await npmInstall(GIT_REPO_ROOT, 'Racine', ctx)]);
 
   if (ctx.dryRun) {
     return { status: 'skipped', note: 'Mode simulation — aucune installation effectuée.' };
@@ -116,8 +116,8 @@ export async function install(ctx) {
 }
 
 export async function check(ctx) {
-  const rootInstalled = fs.existsSync(path.join(REPO_ROOT, 'node_modules'));
-  const ptyReady = repairNodePtySpawnHelpers(REPO_ROOT, { repair: false }).ready;
+  const rootInstalled = fs.existsSync(path.join(GIT_REPO_ROOT, 'node_modules'));
+  const ptyReady = repairNodePtySpawnHelpers(GIT_REPO_ROOT, { repair: false }).ready;
 
   if (rootInstalled && ptyReady) return { status: 'done', note: '' };
   if (rootInstalled) {

package/server/piecemaker/vendor/installer/steps/06-hooks.mjs

@@ -1,8 +1,7 @@
 /**
- * Étape 06 — hooks Claude Code (protection, commits, facturation).
+ * Étape 06 — hooks Claude Code (protection des pièces, recherche, documents IA).
  *
- * Écrit la configuration d'exécution des hooks dans ~/.piecemaker/config.json,
- * puis prouve que chaque script tourne proprement en lui envoyant une charge
+ * Prouve que chaque script tourne proprement en lui envoyant une charge
  * utile synthétique sur stdin — le contrat exact qu'utilise Claude Code (voir
  * piecemaker-plugin/scripts/lib/hook-io.mjs).
  *
@@ -17,8 +16,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { log, spinner } from '../lib/ui.mjs';
-import { REPO_ROOT, HOME_DIR, runCapture, ensureDir } from '../lib/platform.mjs';
-import { updateConfig } from '../lib/state.mjs';
+import { HOME_DIR, REPO_ROOT, runCapture } from '../lib/platform.mjs';
 
 const require = createRequire(import.meta.url);
 const {
@@ -30,21 +28,17 @@ const {
 
 export const meta = {
   id: '06-hooks',
-  label: 'Hooks Claude Code (protection, commits & facturation)',
-  description: 'Configure les garde-fous, les commits PostToolUse et le suivi de facturation',
+  label: 'Hooks Claude Code (protection des pièces)',
+  description: 'Configure les garde-fous et les hooks de recherche et de classement des documents IA',
 };
 
 const PLUGIN_ROOT = path.join(REPO_ROOT, 'piecemaker-plugin');
 const SCRIPTS_DIR = path.join(PLUGIN_ROOT, 'scripts');
 const HOOKS_JSON = path.join(PLUGIN_ROOT, 'hooks', 'hooks.json');
-const BILLING_DIR = path.join(HOME_DIR, 'billing');
-const SYNTHESE_DIR = path.join(BILLING_DIR, 'synthese');
 
 const HOOK_SCRIPTS = {
   protect: path.join(SCRIPTS_DIR, 'protect-originals.mjs'),
-  commit: path.join(SCRIPTS_DIR, 'commit-track.mjs'),
   classify: path.join(SCRIPTS_DIR, 'classify-ai-documents.mjs'),
-  billing: path.join(SCRIPTS_DIR, 'billing-track.mjs'),
   statusline: path.join(SCRIPTS_DIR, 'statusline.mjs'),
 };
 
@@ -73,29 +67,12 @@ function runHookSelfTest(label, scriptPath, payload) {
       return { label, ok: false, note: 'sortie stdout non-JSON — contrat de hook invalide' };
     }
   }
-  return { label, ok: true, note: result.stdout ? 'sortie JSON valide' : 'exit 0 (aucune sortie)' };
+  return { label, ok: true, stdout: result.stdout, note: result.stdout ? 'sortie JSON valide' : 'exit 0 (aucune sortie)' };
 }
 
 export async function install(ctx) {
-  log.step('Répertoires de facturation...');
-  if (!ctx.dryRun) {
-    ensureDir(BILLING_DIR);
-    ensureDir(SYNTHESE_DIR);
-  }
-  log.ok(`${BILLING_DIR}`);
-
   if (ctx.dryRun) {
-    log.info('[simulation] configuration commits/facturation non écrite');
     log.info('[simulation] hooks PieceMaker fusionnés directement dans ~/.claude/settings.json');
-  } else {
-    updateConfig({
-      commits: { enabled: true, timeoutMs: 8000 },
-      billing: { enabled: true },
-    });
-    log.ok('Configuration écrite dans ~/.piecemaker/config.json (commits, billing)');
-  }
-
-  if (ctx.dryRun) {
     return { status: 'skipped', note: 'Mode simulation — hooks non vérifiés.' };
   }
 
@@ -109,10 +86,14 @@ export async function install(ctx) {
     // Un vrai dossier juridique factice, sans point de tête : les hooks
     // ignorent les répertoires cachés, un bac de test caché ne prouverait donc
     // rien du garde-fou. Comme seul un projet publié est un dossier juridique,
-    // on le publie le temps du test sous une source dédiée, retirée ensuite.
-    testDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'piecemaker-hook-selftest-')));
+    // on le publie le temps du test sous une source dédiée, retirée ensuite,
+    // et comme anonymisé : le garde-fou n'agit que sous un bouclier vert.
+    // Les dossiers temporaires du système ne sont jamais des dossiers
+    // juridiques : le bac vit donc dans le répertoire PieceMaker.
+    fs.mkdirSync(HOME_DIR, { recursive: true });
+    testDir = fs.realpathSync(fs.mkdtempSync(path.join(HOME_DIR, 'hook-selftest-')));
     fs.writeFileSync(path.join(testDir, 'piece-selftest.pdf'), 'PIECE DE TEST', 'utf8');
-    publishProjectSource('installer-selftest', [testDir]);
+    publishProjectSource('installer-selftest', [testDir], [testDir]);
     selftestRegistered = true;
 
     // 1. protect-originals.mjs — une pièce du bac de test : protégée par
@@ -127,38 +108,15 @@ export async function install(ctx) {
       tool_input: { file_path: path.join(testDir, 'piece-selftest.pdf') },
       tool_use_id: 'toolu_installer_originals_selftest',
     });
+    if (protectedResult.ok && !/"permissionDecision"\s*:\s*"deny"/.test(protectedResult.stdout || '')) {
+      protectedResult.ok = false;
+      protectedResult.note = 'la pièce du bac de test n\'a pas été bloquée';
+    } else if (protectedResult.ok) {
+      protectedResult.note = 'pièce protégée bloquée';
+    }
     testResults.push(protectedResult);
 
-    // 2. commit-track.mjs — réponse d'outil en échec : exerce le contrat
-    //    d'entrée/sortie sans créer de vrai commit pendant l'installation.
-    const commitResult = runHookSelfTest('commit-track.mjs', HOOK_SCRIPTS.commit, {
-      hook_event_name: 'PostToolUse',
-      session_id: 'installer-selftest',
-      cwd: REPO_ROOT,
-      transcript_path: '',
-      permission_mode: 'default',
-      tool_name: 'Edit',
-      tool_input: { file_path: path.join(REPO_ROOT, 'README.md') },
-      tool_response: { success: false },
-      tool_use_id: 'toolu_installer_commit_selftest',
-    });
-    testResults.push(commitResult);
-
-    // 3. billing-track.mjs — une vraie charge utile Stop : ajoute une ligne
-    //    (clairement identifiée) au registre du mois et écrit une synthèse,
-    //    ce qui prouve le chemin d'écriture de bout en bout.
-    const billingResult = runHookSelfTest('billing-track.mjs', HOOK_SCRIPTS.billing, {
-      hook_event_name: 'Stop',
-      session_id: 'installer-selftest',
-      cwd: REPO_ROOT,
-      transcript_path: path.join(testDir, 'transcript-selftest.jsonl'),
-      permission_mode: 'default',
-      last_assistant_message: 'Test d\'installation PieceMaker — vérification du hook de facturation.',
-      stop_reason: 'end_turn',
-    });
-    testResults.push(billingResult);
-
-    // 4. classify-ai-documents.mjs — un document « créé par l'IA » dans le bac
+    // 2. classify-ai-documents.mjs — un document « créé par l'IA » dans le bac
     //    de test enregistré doit ressortir classé « espace de travail » dans
     //    `.piecemaker/protection.json`, sans quoi l'IA ne pourrait pas se
     //    relire. On vérifie l'effet de bord, pas seulement le code de sortie.
@@ -201,7 +159,6 @@ export async function install(ctx) {
     if (r.ok) log.ok(`${r.label} : ${r.note}`);
     else log.error(`${r.label} : ${r.note}`);
   }
-  log.detail(`Une ligne de test a été ajoutée à ${path.join(BILLING_DIR, `${new Date().toISOString().slice(0, 7)}.jsonl`)} (session "installer-selftest") — supprimez-la si besoin.`);
   if (!fs.existsSync(HOOKS_JSON)) {
     log.warn(`hooks/hooks.json introuvable dans le plugin : ${HOOKS_JSON}`);
   }
@@ -232,12 +189,9 @@ export async function install(ctx) {
   return { status: 'done', note: '' };
 }
 
-export async function check(ctx) {
+export async function check() {
   const scriptsExist = Object.values(HOOK_SCRIPTS).every((p) => fs.existsSync(p));
   const hooksJsonExists = fs.existsSync(HOOKS_JSON);
-  const dirsExist = fs.existsSync(BILLING_DIR) && fs.existsSync(SYNTHESE_DIR);
-  const cfg = ctx.config || {};
-  const configOk = Boolean(cfg.commits && cfg.billing);
   const hooksRegistered = claudeHooksStatus(REPO_ROOT, os.homedir()).ok;
   const statusLine = claudeStatusLineStatus(REPO_ROOT, os.homedir());
   const statusLineOk = statusLine.ok || statusLine.conflict; // une statusLine personnelle n'est pas une anomalie
@@ -245,8 +199,8 @@ export async function check(ctx) {
   if (!scriptsExist || !hooksJsonExists) {
     return { status: 'failed', note: 'Fichiers du plugin manquants (scripts ou hooks.json) — réinstallez piecemaker-plugin/.' };
   }
-  if (!dirsExist || !configOk || !hooksRegistered) {
-    return { status: 'partial', note: 'Scripts présents mais configuration, enregistrement Claude ou répertoires de facturation incomplets — relancez cette étape.' };
+  if (!hooksRegistered) {
+    return { status: 'partial', note: 'Scripts présents mais hooks non enregistrés dans Claude Code — relancez cette étape.' };
   }
   if (!statusLineOk) {
     return { status: 'partial', note: `statusLine Claude Code absente ou périmée (${statusLine.reason}) — relancez cette étape.` };

package/server/piecemaker/vendor/installer/steps/12-mcp-piecemaker.mjs

@@ -1,5 +1,5 @@
 /**
- * Étape 12 — serveur MCP « piecemaker » (conversion, chronologie).
+ * Étape 12 — serveur MCP « piecemaker » (conversion).
  *
  * Les commandes de conversion sont aujourd'hui présentées au
  * modèle par du texte injecté dans les templates, sans rien qui relie ce
@@ -21,8 +21,8 @@ import { REPO_ROOT, commandExists, run, runCapture } from '../lib/platform.mjs';
 
 export const meta = {
   id: '12-mcp-piecemaker',
-  label: 'Serveur MCP piecemaker (conversion, chronologie)',
-  description: 'Enregistre dans Claude Code le serveur MCP qui expose la conversion et la chronologie',
+  label: 'Serveur MCP piecemaker (conversion)',
+  description: 'Enregistre dans Claude Code le serveur MCP qui expose la conversion',
 };
 
 const SERVER_NAME = 'piecemaker';

package/server/piecemaker/vendor/mcp/README.md

@@ -1,7 +1,7 @@
 # MCP PieceMaker
 
 Point d'entrée du serveur MCP `piecemaker` (`piecemaker/server.mjs`), qui expose
-les outils `chronologie` et `conversion` en pilotant
+l'outil `conversion` en pilotant
 `installer/bin/piecemaker.mjs`.
 
 - `REPO_ROOT`, calculé deux niveaux au-dessus de ce fichier, résout vers

package/server/piecemaker/vendor/mcp/piecemaker/server.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Serveur MCP « piecemaker » — outils de conversion et de chronologie exposés
+ * Serveur MCP « piecemaker » — outil de conversion exposé
  * à Claude Code (et à tout client MCP) sans passer
  * par du texte injecté dans un CLAUDE.md.
  *
@@ -10,10 +10,10 @@
  * d'arguments, même localisation de dossier, une seule implémentation
  * (voir `installer/bin/piecemaker.mjs`).
  *
- * Les commandes lancées ici (`conversion --json`, `chronology --json`, `chronology --action write/edit
- * --json`) court-circuitent toutes le bandeau, la vérification de mise à jour
- * et le menu interactif (`installer/bin/piecemaker.mjs:1006-1009`) : aucun
- * service PieceMaker n'est démarré, arrêté ni redémarré par ce serveur.
+ * La commande lancée ici (`conversion --json`) court-circuite le bandeau, la
+ * vérification de mise à jour et le menu interactif. Elle confie le travail au
+ * serveur applicatif déjà lancé (application de bureau ou `piecemaker`) et ne
+ * démarre un serveur que si aucun ne répond.
  */
 
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -95,28 +95,6 @@ export function conversionArgs({ dossier, pieces, force }) {
   return args;
 }
 
-export function chronologyArgs({ dossier }) {
-  return ['chronology', '--json', '--case', dossier];
-}
-
-export function chronologyCorrectionArgs(action, { dossier, path: piecePath, nature, dateIso, localisation, fields, entityAdditions, entityExclusions, reason }) {
-  const correction = {};
-  if (nature !== undefined) correction.nature = nature;
-  if (dateIso !== undefined) correction.dateIso = dateIso;
-  if (localisation !== undefined) correction.localisation = localisation;
-  if (fields !== undefined) correction.fields = fields;
-  if (reason !== undefined) correction.reason = reason;
-  if (entityAdditions !== undefined || entityExclusions !== undefined) {
-    correction.entityDecisions = {
-      additions: entityAdditions || [],
-      exclusions: entityExclusions || [],
-    };
-  }
-  const args = ['chronology', '--action', action, '--path', piecePath, '--correction-json', JSON.stringify(correction), '--json'];
-  if (dossier) args.push('--case', dossier);
-  return args;
-}
-
 /** Dossier ciblé par un appel d'outil : celui demandé, sinon la session en cours. */
 export function resolveDossier(dossier) {
   return dossier && String(dossier).trim() ? dossier : process.cwd();
@@ -126,21 +104,6 @@ const DOSSIER_SCHEMA = z.string()
   .optional()
   .describe('Chemin absolu du dossier juridique ciblé. Par défaut, le répertoire de la session Claude Code en cours.');
 
-const CHRONOLOGY_CORRECTION_SCHEMA = {
-  dossier: DOSSIER_SCHEMA,
-  path: z.string().min(1).describe('Chemin relatif de la pièce, tel qu\'indexé par la chronologie.'),
-  nature: z.string().optional().describe('Nature de l\'acte (ex. « Assignation », « Conclusions »).'),
-  dateIso: z.string().optional().describe('Date de la pièce au format ISO 8601 (AAAA-MM-JJ).'),
-  localisation: z.string().optional().describe('Juridiction ou localisation associée à la pièce.'),
-  fields: z.array(z.object({ label: z.string(), value: z.string() })).optional()
-    .describe('Champs personnalisés additionnels de la pièce.'),
-  entityAdditions: z.array(z.string()).optional()
-    .describe('Codes d\'entités (personnes/sociétés pseudonymisées) à rattacher manuellement à la pièce.'),
-  entityExclusions: z.array(z.string()).optional()
-    .describe('Codes d\'entités détectés automatiquement à exclure manuellement de la pièce.'),
-  reason: z.string().optional().describe('Motif de la correction, consigné dans l\'historique du dossier.'),
-};
-
 /**
  * Construit le serveur MCP et y enregistre les outils. Séparé de
  * `main()` pour rester testable sans jamais brancher de transport stdio.
@@ -160,45 +123,19 @@ export function createServer({ execFn } = {}) {
         .describe('Noms ou chemins relatifs des pièces à convertir. Par défaut, toutes les pièces pas encore prêtes.'),
       force: z.boolean().optional().describe('Reconvertit et rescanne même les pièces déjà prêtes.'),
     },
+    annotations: {
+      title: 'Conversion et pseudonymisation des pièces',
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
   }, async ({ dossier, pieces, force }) => {
     const resolved = resolveDossier(dossier);
     const result = await run(conversionArgs({ dossier: resolved, pieces, force }), resolved);
     return toToolResult(result);
   });
 
-  server.registerTool('chronologie', {
-    description: 'Affiche la chronologie pseudonymisée du dossier juridique (dates, pièces, événements), en JSON.',
-    inputSchema: {
-      dossier: DOSSIER_SCHEMA,
-    },
-  }, async ({ dossier }) => {
-    const resolved = resolveDossier(dossier);
-    const result = await run(chronologyArgs({ dossier: resolved }), resolved);
-    return toToolResult(result);
-  });
-
-  server.registerTool('write_chronology', {
-    description: 'Crée une correction manuelle de chronologie pour une pièce (date, nature d\'acte, '
-      + 'localisation, personnes citées, champs custom). Échoue si une correction existe déjà pour cette '
-      + 'pièce — utiliser edit_chronology pour la modifier.',
-    inputSchema: CHRONOLOGY_CORRECTION_SCHEMA,
-  }, async ({ dossier, ...params }) => {
-    const resolved = resolveDossier(dossier);
-    const result = await run(chronologyCorrectionArgs('write', { dossier: resolved, ...params }), resolved);
-    return toToolResult(result);
-  });
-
-  server.registerTool('edit_chronology', {
-    description: 'Modifie la correction manuelle de chronologie déjà enregistrée pour une pièce (date, '
-      + 'nature d\'acte, localisation, personnes citées, champs custom). Échoue si aucune correction '
-      + 'n\'existe pour cette pièce — utiliser write_chronology pour en créer une.',
-    inputSchema: CHRONOLOGY_CORRECTION_SCHEMA,
-  }, async ({ dossier, ...params }) => {
-    const resolved = resolveDossier(dossier);
-    const result = await run(chronologyCorrectionArgs('edit', { dossier: resolved, ...params }), resolved);
-    return toToolResult(result);
-  });
-
   return server;
 }
 

package/server/piecemaker/vendor/piecemaker-plugin/hooks/hooks.json

@@ -21,15 +21,6 @@
           }
         ]
       },
-      {
-        "matcher": "Write|Edit",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/commit-track.mjs\""
-          }
-        ]
-      },
       {
         "matcher": "Write",
         "hooks": [
@@ -48,37 +39,6 @@
           }
         ]
       }
-    ],
-    "Stop": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/billing-track.mjs\""
-          }
-        ]
-      },
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/session-commit.mjs\""
-          }
-        ]
-      }
-    ],
-    "TaskCompleted": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/billing-track.mjs\""
-          }
-        ]
-      }
     ]
   }
 }

package/server/piecemaker/vendor/piecemaker-plugin/scripts/compile-recherche.mjs

@@ -72,8 +72,8 @@ async function main() {
   const pdfPath = path.join(rechercheDir, `${slug}.pdf`);
 
   // Le modèle n'a vu que des codes ; l'historique du cabinet doit rester
-  // lisible → on ré-identifie le Markdown final avant écriture disque (même
-  // logique que commit-track sur les libellés). Idempotent.
+  // lisible → on ré-identifie le Markdown final avant écriture disque.
+  // Idempotent.
   let markdown = renderMarkdown(data, { caseName: located.caseName });
   const legalCase = resolveProjectCaseMapping(located.caseRoot);
   if (legalCase?.reverse_mapping) markdown = revertMapping(markdown, legalCase.reverse_mapping);

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/case-folder-structure.cjs

@@ -7,7 +7,6 @@ const CASE_FOLDER_STRUCTURE_VERSION = 1;
 const CASE_FOLDER_STRUCTURE_RELATIVE = '.piecemaker/case-folder-structure.json';
 
 const DEFAULT_CASE_FOLDER_STRUCTURE = Object.freeze({
-  administrative: '00_ADMINISTRATIF_ET_FACTURATION',
   correspondence: '01_CORRESPONDANCE',
   correspondenceClient: '01_Client',
   correspondenceOpposingCounsel: '02_Avocats_adverses',
@@ -65,7 +64,6 @@ function normalizeCaseFolderStructure(value = {}) {
   }
 
   ensureUniqueSiblingNames(structure, [
-    'administrative',
     'correspondence',
     'dataRoom',
     'drafts',
@@ -107,9 +105,8 @@ function readStructureManifest(caseRoot) {
 }
 
 /**
- * La structure est figée par dossier lors de son premier enregistrement. Ainsi,
- * personnaliser les prochains dossiers ne change pas le routage du Markdown
- * des dossiers déjà existants.
+ * Seuls les anciens dossiers portent encore un manifeste d'arborescence : il
+ * continue de router leur Markdown. Sans manifeste, le dossier n'est pas géré.
  */
 function readCaseFolderStructure(caseRoot, config = {}) {
   const manifest = readStructureManifest(caseRoot);
@@ -119,78 +116,6 @@ function readCaseFolderStructure(caseRoot, config = {}) {
   };
 }
 
-function caseFolderDirectoriesFromStructure(structure) {
-  return [
-    structure.administrative,
-    structure.correspondence,
-    path.join(structure.correspondence, structure.correspondenceMarkdown),
-    path.join(structure.correspondence, structure.correspondenceClient),
-    path.join(structure.correspondence, structure.correspondenceOpposingCounsel),
-    path.join(structure.correspondence, structure.correspondenceThirdParties),
-    structure.dataRoom,
-    path.join(structure.dataRoom, structure.dataRoomMarkdown),
-    structure.drafts,
-    structure.notesAndResearch,
-    structure.procedure,
-  ];
-}
-
-/** Chemins relatifs, dans l'ordre lisible de l'arborescence documentée. */
-function caseFolderDirectories(config = {}) {
-  return caseFolderDirectoriesFromStructure(configuredCaseFolderStructure(config));
-}
-
-function writeStructureManifest(file, structure) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  const temporary = `${file}.piecemaker-${process.pid}.tmp`;
-  fs.writeFileSync(temporary, `${JSON.stringify({
-    version: CASE_FOLDER_STRUCTURE_VERSION,
-    structure,
-  }, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
-  fs.renameSync(temporary, file);
-}
-
-/**
- * Crée uniquement les dossiers manquants. Aucun fichier ni dossier existant
- * n'est renommé ou remplacé quand l'utilisateur modifie les noms par défaut.
- */
-function ensureCaseFolderStructure(caseRoot, config = {}) {
-  const requested = String(caseRoot || '').trim();
-  if (!requested || !path.isAbsolute(requested)) throw new Error('Racine du dossier juridique invalide.');
-  const root = path.resolve(requested);
-  let rootStat;
-  try {
-    rootStat = fs.statSync(root);
-  } catch {
-    throw new Error('Racine du dossier juridique introuvable.');
-  }
-  if (!rootStat.isDirectory()) throw new Error('Racine du dossier juridique invalide.');
-
-  const created = [];
-  const manifest = readStructureManifest(root);
-  const structure = manifest.structure || configuredCaseFolderStructure(config);
-  const directories = caseFolderDirectoriesFromStructure(structure);
-  for (const relative of directories) {
-    const target = path.join(root, relative);
-    if (fs.existsSync(target)) {
-      if (!fs.statSync(target).isDirectory()) {
-        throw new Error(`L’emplacement « ${relative} » existe mais n’est pas un dossier.`);
-      }
-      continue;
-    }
-    fs.mkdirSync(target, { recursive: true });
-    created.push(relative.split(path.sep).join('/'));
-  }
-  if (!manifest.exists) writeStructureManifest(manifest.file, structure);
-
-  return {
-    file: manifest.file,
-    names: structure,
-    directories: directories.map((relative) => relative.split(path.sep).join('/')),
-    created,
-  };
-}
-
 function relativeSegments(relativePath) {
   const value = String(relativePath || '').replaceAll('\\', '/').replace(/^\.\//, '');
   if (!value || value.startsWith('/') || value.split('/').some((segment) => !segment || segment === '.' || segment === '..')) {
@@ -278,20 +203,7 @@ function structuredMarkdownCounterpart(absolutePath, caseRoot, config = {}) {
 }
 
 module.exports = {
-  CASE_FOLDER_KEYS,
-  CASE_FOLDER_STRUCTURE_KEY,
-  CASE_FOLDER_STRUCTURE_RELATIVE,
-  DEFAULT_CASE_FOLDER_STRUCTURE,
-  caseConversionOutputDirectory,
-  caseFolderDirectories,
-  caseFolderStructureFile,
-  classifyCaseFolderPath,
   classifyRelativeCaseFolderPath,
-  configuredCaseFolderStructure,
-  ensureCaseFolderStructure,
-  isCaseGeneratedPath,
-  normalizeCaseFolderStructure,
   readCaseFolderStructure,
   structuredMarkdownCounterpart,
-  validateCaseFolderName,
 };

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/case-folders.cjs

@@ -4,6 +4,7 @@ const os = require('node:os');
 const path = require('node:path');
 
 const PROJECTS_FILE = 'projects.json';
+const ANONYMIZED_PROJECTS_FILE = 'anonymized-projects.json';
 
 function piecemakerHome() {
   return process.env.PIECEMAKER_HOME || path.join(os.homedir(), '.piecemaker');
@@ -13,6 +14,10 @@ function projectsFile() {
   return path.join(piecemakerHome(), PROJECTS_FILE);
 }
 
+function anonymizedProjectsFile() {
+  return path.join(piecemakerHome(), ANONYMIZED_PROJECTS_FILE);
+}
+
 function realDirectory(value) {
   const requested = String(value || '').trim();
   if (!requested || !path.isAbsolute(requested)) return null;
@@ -41,24 +46,31 @@ function isEligibleProjectFolder(folder) {
   return !excludedRoots().some((root) => isInsideOrEqualPath(root, folder));
 }
 
-function readProjectSources() {
+function readSources(file) {
   try {
-    const parsed = JSON.parse(fs.readFileSync(projectsFile(), 'utf8'));
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
     return parsed?.sources && typeof parsed.sources === 'object' && !Array.isArray(parsed.sources) ? parsed.sources : {};
   } catch {
     return {};
   }
 }
 
+function publishedFolders(file) {
+  const folders = Object.values(readSources(file)).flatMap((list) => (Array.isArray(list) ? list : []));
+  return [...new Set(folders.map(realDirectory).filter(Boolean))].filter(isEligibleProjectFolder);
+}
+
 /** Absolute, existing and de-duplicated project folders, across every publishing server. */
 function registeredProjectFolders() {
-  const folders = Object.values(readProjectSources()).flatMap((list) => (Array.isArray(list) ? list : []));
-  return [...new Set(folders.map(realDirectory).filter(Boolean))].filter(isEligibleProjectFolder);
+  return publishedFolders(projectsFile());
+}
+
+function anonymizedProjectFolders() {
+  return publishedFolders(anonymizedProjectsFile());
 }
 
-function publishProjectSource(sourceId, folders) {
-  const file = projectsFile();
-  const sources = readProjectSources();
+function writeSource(file, sourceId, folders) {
+  const sources = readSources(file);
   if (folders === null) delete sources[sourceId];
   else sources[sourceId] = [...new Set(folders.map((folder) => path.resolve(String(folder))))].sort();
   fs.mkdirSync(path.dirname(file), { recursive: true });
@@ -72,6 +84,11 @@ function publishProjectSource(sourceId, folders) {
   }
 }
 
+function publishProjectSource(sourceId, folders, anonymizedFolders = []) {
+  writeSource(projectsFile(), sourceId, folders);
+  writeSource(anonymizedProjectsFile(), sourceId, folders === null ? null : anonymizedFolders);
+}
+
 function resolveTarget(target) {
   try {
     return fs.realpathSync(path.resolve(String(target)));
@@ -101,6 +118,7 @@ function locateProjectCase(target) {
   for (const caseRoot of roots) {
     if (!isInsideOrEqualPath(caseRoot, absolute)) continue;
     return {
+      anonymized: anonymizedProjectFolders().includes(caseRoot),
       casesRoot: path.dirname(caseRoot),
       caseName: path.basename(caseRoot),
       caseRoot,
@@ -113,6 +131,7 @@ function locateProjectCase(target) {
 }
 
 module.exports = {
+  anonymizedProjectFolders,
   locateProjectCase,
   publishProjectSource,
   registeredProjectFolders,