@piecemaker-legal/piecemaker 1.0.6 → 1.0.8

package/server/modules/database/tests/projects.db.integration.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import test from 'node:test';
 
-import { closeConnection } from '@/modules/database/connection.js';
+import { closeConnection, getConnection } from '@/modules/database/connection.js';
 import { initializeDatabase } from '@/modules/database/init-db.js';
 import { projectsDb } from '@/modules/database/repositories/projects.db.js';
 
@@ -70,3 +70,65 @@ test('projectsDb.createProjectPath returns active_conflict for active duplicates
     assert.equal(conflict.project?.isArchived, 0);
   });
 });
+
+test('projectsDb.getProjectPaths reads anonymization completion directly from SQLite', async () => {
+  await withIsolatedDatabase(() => {
+    const created = projectsDb.createProjectPath('/workspace/anonymized-project');
+    assert.ok(created.project);
+
+    projectsDb.getProjectPaths();
+    getConnection().prepare(`
+      INSERT INTO piecemaker_anonymization_status (project_id, completed_at)
+      VALUES (?, ?)
+    `).run(created.project.project_id, new Date().toISOString());
+
+    const project = projectsDb.getProjectPaths()[0];
+    assert.equal(project.anonymization_complete, 1);
+  });
+});
+
+test('projectsDb.getProjectPaths backfills anonymization completion from existing mappings', async () => {
+  await withIsolatedDatabase(() => {
+    const created = projectsDb.createProjectPath('/workspace/legacy-scanned-project');
+    assert.ok(created.project);
+    const db = getConnection();
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS piecemaker_nodes (
+        project_id TEXT NOT NULL,
+        id TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        label TEXT NOT NULL,
+        search_text TEXT NOT NULL DEFAULT '',
+        aliases_json TEXT NOT NULL DEFAULT '[]',
+        data_json TEXT NOT NULL DEFAULT '{}',
+        origin TEXT NOT NULL DEFAULT 'gliner',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (project_id, id)
+      );
+      CREATE TABLE IF NOT EXISTS piecemaker_mappings (
+        project_id TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        real_value TEXT NOT NULL,
+        masked_value TEXT NOT NULL,
+        search_text TEXT NOT NULL DEFAULT '',
+        data_json TEXT NOT NULL DEFAULT '{}',
+        origin TEXT NOT NULL DEFAULT 'gliner',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (project_id, node_id, real_value)
+      );
+    `);
+    db.prepare(`
+      INSERT INTO piecemaker_nodes(project_id,id,kind,label,search_text,aliases_json,data_json,origin,created_at,updated_at)
+      VALUES (?, 'person-1', 'person', 'Alice', 'alice', '[]', '{}', 'gliner', ?, ?)
+    `).run(created.project.project_id, new Date().toISOString(), new Date().toISOString());
+    db.prepare(`
+      INSERT INTO piecemaker_mappings(project_id,node_id,real_value,masked_value,search_text,data_json,origin,created_at,updated_at)
+      VALUES (?, 'person-1', 'Alice', 'PERSONNE_PHYSIQUE_01', 'alice', '{}', 'gliner', ?, ?)
+    `).run(created.project.project_id, new Date().toISOString(), new Date().toISOString());
+
+    const project = projectsDb.getProjectPaths()[0];
+    assert.equal(project.anonymization_complete, 1);
+  });
+});

package/server/modules/plugins/plugins.routes.ts

@@ -26,8 +26,15 @@ export function createPluginsRouter(service: ReturnType<typeof createPluginsServ
   router.get('/:name/assets/*', async (req, res, next) => {
     try {
       const asset = service.resolveAsset(routeParameter(req.params.name), wildcardPath(req));
+      const stats = fs.statSync(asset.path);
+      const etag = `"${stats.mtimeMs.toString(16)}-${stats.size.toString(16)}"`;
       res.setHeader('Content-Type', asset.contentType);
-      res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
+      res.setHeader('ETag', etag);
+      res.setHeader('Cache-Control', 'private, max-age=0, must-revalidate');
+      if (req.headers['if-none-match'] === etag) {
+        res.status(304).end();
+        return;
+      }
       const stream = fs.createReadStream(asset.path);
       stream.on('error', next);
       stream.pipe(res);

package/server/modules/projects/services/projects-with-sessions-fetch.service.ts

@@ -29,6 +29,7 @@ export type ProjectListItem = {
   displayName: string;
   fullPath: string;
   isStarred: boolean;
+  anonymizationComplete: boolean;
   sessions: SessionSummary[];
   sessionMeta: {
     hasMore: boolean;
@@ -189,6 +190,7 @@ export async function getProjectsWithSessions(
     project_path: string;
     custom_project_name?: string | null;
     isStarred?: number;
+    anonymization_complete?: number;
   }>;
   const totalProjects = projectRows.length;
   const projects: ProjectListItem[] = [];
@@ -223,6 +225,7 @@ export async function getProjectsWithSessions(
       displayName,
       fullPath: projectPath,
       isStarred: Boolean(row.isStarred),
+      anonymizationComplete: Boolean(row.anonymization_complete),
       sessions: sessionsPage.sessions,
       sessionMeta: {
         hasMore: sessionsPage.hasMore,
@@ -257,6 +260,7 @@ export async function getArchivedProjectsWithSessions(
     project_path: string;
     custom_project_name?: string | null;
     isStarred?: number;
+    anonymization_complete?: number;
   }>;
 
   const archivedProjects: ArchivedProjectListItem[] = [];
@@ -275,6 +279,7 @@ export async function getArchivedProjectsWithSessions(
       displayName,
       fullPath: row.project_path,
       isStarred: Boolean(row.isStarred),
+      anonymizationComplete: Boolean(row.anonymization_complete),
       isArchived: true,
       sessions: sessionsPage.sessions,
       sessionMeta: {

package/server/piecemaker/anonymizer/client-config.cjs

@@ -138,10 +138,18 @@ function configureCodexProxy({
 
   const managedTable = lines.findIndex((line) => line.trim() === `[model_providers.${CODEX_PROVIDER_ID}]`);
   const managedStart = lines.findIndex((line) => line.trim() === CODEX_BLOCK_START);
-  const managedEnd = lines.findIndex((line) => line.trim() === CODEX_BLOCK_END);
-  if (managedTable >= 0 && (managedStart < 0 || managedEnd < managedTable)) {
+  let managedEnd = lines.findIndex((line) => line.trim() === CODEX_BLOCK_END);
+  if (managedTable >= 0 && managedStart < 0) {
     return { configured: false, changed: false, conflict: true, file: configFile, reason: 'provider-table-conflict' };
   }
+  if (managedStart >= 0 && managedEnd < managedStart) {
+    let end = managedTable >= managedStart ? managedTable : managedStart;
+    for (let index = end + 1; index < lines.length; index += 1) {
+      if (/^\s*\[/.test(lines[index])) break;
+      end = index;
+    }
+    managedEnd = end;
+  }
 
   if (provider) {
     lines[provider.index] = `model_provider = ${tomlString(CODEX_PROVIDER_ID)} # géré par PieceMaker`;

package/server/piecemaker/anonymizer/dictionary.cjs

@@ -1,23 +1,14 @@
 /**
  * Dictionnaire d'anonymisation du proxy PII.
  *
- * Source unique : le mapping central écrit par `central-mapping.cjs` lors de
- * l'enregistrement d'un mapping de dossier. Il réunit tous les dossiers
- * enregistrés avec des codes dé-conflictés, ce qui est exactement ce qu'un
- * chokepoint réseau demande : un nom appartenant au dossier B doit rester
- * protégé même s'il est tapé dans une conversation ouverte sur le dossier A.
- * Un proxy par dossier ne saurait pas le faire.
+ * Le proxy charge le dictionnaire depuis SQLite (`sqlite-dictionary.cjs`,
+ * tables `piecemaker_mappings` / `piecemaker_nodes`). Ce module construit la
+ * forme exploitable (`buildDictionary`) et applique la substitution.
  *
- * Le fichier contient des noms réels (mode 0600). Il n'est jamais servi tel
- * quel : `routes.cjs` n'en expose que ce dont l'interface a besoin pour
- * surligner, et seulement derrière l'authentification CloudCLI.
- *
- * Rechargement à chaud sur `mtime` : une conversion qui ré-écrit le mapping est
- * prise en compte sans redémarrer CloudCLI.
+ * Un nom appartenant au dossier B doit rester protégé même s'il est tapé dans
+ * une conversation ouverte sur le dossier A. Un proxy par dossier ne saurait
+ * pas le faire.
  */
-const fs = require('node:fs');
-const path = require('node:path');
-
 const {
   applyMapping,
   buildEntityRegex,
@@ -25,8 +16,6 @@ const {
   MIN_ENTITY_LENGTH,
 } = require('../vendor/piecemaker-plugin/scripts/lib/substitution.cjs');
 
-const CENTRAL_FILENAME = 'central-mapping.json';
-
 /** Un dictionnaire vide se comporte comme un proxy transparent. */
 const EMPTY = Object.freeze({
   version: 0,
@@ -41,14 +30,6 @@ const EMPTY = Object.freeze({
   empty: true,
 });
 
-function readJson(file) {
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8').replace(/^/, ''));
-  } catch {
-    return null;
-  }
-}
-
 function plainObject(value) {
   return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
@@ -66,7 +47,6 @@ function plainObject(value) {
  * moteur refuse de substituer (`buildEntityRegex` nul : ponctuation pure, deux
  * caractères non acronymiques) est écartée des deux listes : surligner ce qui
  * ne part pas codé serait un mensonge à l'écran.
- *
  */
 function buildDictionary(document, stamp) {
   const mapping = plainObject(document?.mapping);
@@ -107,50 +87,6 @@ function buildDictionary(document, stamp) {
   };
 }
 
-/**
- * Chargeur à cache : relit le fichier uniquement quand sa signature
- * (mtime + taille) change. `version` s'incrémente à chaque rechargement effectif,
- * ce qui sert de clé de cache aux consommateurs (client compris).
- */
-function createDictionaryLoader({ homeDir }) {
-  const file = path.join(homeDir, CENTRAL_FILENAME);
-  let signature = null;
-  let current = EMPTY;
-  let generation = 0;
-
-  function statSignature() {
-    try {
-      const stats = fs.statSync(file);
-      return `${stats.mtimeMs}:${stats.size}`;
-    } catch {
-      return null;
-    }
-  }
-
-  function load(force = false) {
-    const next = statSignature();
-    if (!force && next === signature) return current;
-    signature = next;
-    if (next === null) {
-      current = EMPTY;
-      return current;
-    }
-    const document = readJson(file);
-    generation += 1;
-    current = document ? buildDictionary(document, generation) : EMPTY;
-    return current;
-  }
-
-  return {
-    file,
-    /** Le dictionnaire à jour, relu si le fichier a bougé. */
-    get: () => load(false),
-    /** Relecture inconditionnelle, pour le bouton « rafraîchir ». */
-    refresh: () => load(true),
-    exists: () => statSignature() !== null,
-  };
-}
-
 /** Nom réel → code, sur tout ce qui part vers l'API. */
 function anonymize(text, dictionary) {
   return dictionary.empty ? text : applyMapping(text, dictionary.mapping);
@@ -162,10 +98,8 @@ function deanonymize(text, dictionary) {
 }
 
 module.exports = {
-  CENTRAL_FILENAME,
   EMPTY_DICTIONARY: EMPTY,
   anonymize,
   buildDictionary,
-  createDictionaryLoader,
   deanonymize,
 };

package/server/piecemaker/bodacc-search.ts

@@ -0,0 +1,205 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import express, { type Request, type Response } from 'express';
+
+type McpContent = {
+  type?: string;
+  text?: string;
+  resource?: { text?: string };
+};
+
+type McpMessage = {
+  id?: number;
+  error?: { message?: string };
+  result?: { content?: McpContent[]; isError?: boolean };
+};
+
+export type BodaccAnnouncement = {
+  id: string;
+  datePublication: string;
+  typeAvis: string;
+  familleAvis: string;
+  commercant: string;
+  ville: string;
+  tribunal: string;
+  jugement: string;
+  acte: string;
+  url: string;
+};
+
+export type BodaccSearchResult = {
+  siren: string;
+  total: number;
+  alertes: string[];
+  annonces: BodaccAnnouncement[];
+};
+
+const BODACC_FAMILY_CODES = new Set([
+  'dpc',
+  'modification',
+  'creation',
+  'radiation',
+  'collective',
+  'vente',
+  'immatriculation',
+  'divers',
+  'conciliation',
+  'retablissement_professionnel',
+  'inconnue',
+]);
+
+const MCP_TIMEOUT_MS = 45_000;
+
+function collectLauncherCandidates(): string[] {
+  const candidates: string[] = [];
+  const addRoot = (root: string | undefined) => {
+    if (root) candidates.push(path.join(root, 'scripts', 'launcher.py'));
+  };
+  addRoot(process.env.LEGIFRANCE_MCP_ROOT);
+  if (process.env.LEGIFRANCE_MCP_LAUNCHER) candidates.push(process.env.LEGIFRANCE_MCP_LAUNCHER);
+  const pluginConfigPath = path.join(os.homedir(), '.claude', 'plugins', 'installed_plugins.json');
+  if (existsSync(pluginConfigPath)) {
+    try {
+      const configuration = JSON.parse(readFileSync(pluginConfigPath, 'utf8')) as { plugins?: Record<string, Array<{ installPath?: string }>> };
+      for (const [plugin, installations] of Object.entries(configuration.plugins || {})) {
+        if (!plugin.includes('mcp-legifrance')) continue;
+        for (const installation of installations) addRoot(installation.installPath);
+      }
+    } catch {
+      return candidates;
+    }
+  }
+  const versionsRoot = path.join(os.homedir(), '.claude', 'plugins', 'cache', 'mcp-legifrance', 'piecemaker');
+  if (existsSync(versionsRoot)) {
+    for (const version of readdirSync(versionsRoot).sort().reverse()) addRoot(path.join(versionsRoot, version));
+  }
+  return [...new Set(candidates)];
+}
+
+function resolveLauncher(): string {
+  const launcher = collectLauncherCandidates().find((candidate) => existsSync(candidate));
+  if (!launcher) throw new Error('Le lanceur du PERS_MORALE_1 Légifrance est introuvable.');
+  return launcher;
+}
+
+function mcpCall(tool: string, argumentsValue: Record<string, string>): Promise<McpMessage> {
+  return new Promise((resolve, reject) => {
+    const processHandle = spawn(process.env.PYTHON_PATH || 'python3', [resolveLauncher()], {
+      env: { ...process.env, PYTHONDONTWRITEBYTECODE: '1' },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let settled = false;
+    const timeout = setTimeout(() => {
+      processHandle.kill('SIGTERM');
+      reject(new Error('Le PERS_MORALE_1 Légifrance n’a pas répondu à temps.'));
+    }, MCP_TIMEOUT_MS);
+    const finish = (callback: () => void) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      callback();
+    };
+    processHandle.stdout.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString();
+      for (const line of stdout.split(/\r?\n/).slice(0, -1)) {
+        try {
+          const message = JSON.parse(line) as McpMessage;
+          if (message.id === 3) finish(() => resolve(message));
+        } catch {
+          continue;
+        }
+      }
+      stdout = stdout.split(/\r?\n/).at(-1) || '';
+    });
+    processHandle.once('error', (error) => finish(() => reject(error)));
+    processHandle.once('close', (code) => {
+      if (!settled) finish(() => reject(new Error(code === null ? 'Le processus Légifrance a été interrompu.' : `Le processus Légifrance s’est arrêté (${code}).`)));
+    });
+    processHandle.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'piecemaker-dossier', version: '0.1.0' } } })}\n`);
+    processHandle.stdin.write('{"jsonrpc":"2.0","method":"notifications/initialized","params":{}}\n');
+    processHandle.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: tool, arguments: argumentsValue } })}\n`);
+    processHandle.stdin.end();
+  });
+}
+
+function normalizedSiren(siren: string, siret: string): string {
+  const sirenDigits = siren.replace(/\D/g, '');
+  if (sirenDigits.length === 9) return sirenDigits;
+  const siretDigits = siret.replace(/\D/g, '');
+  if (siretDigits.length === 14) return siretDigits.slice(0, 9);
+  if (sirenDigits.length === 14) return sirenDigits.slice(0, 9);
+  throw new Error('Un SIREN à 9 chiffres ou un SIRET à 14 chiffres est requis.');
+}
+
+function resultContent(message: McpMessage): McpContent[] {
+  if (message.error?.message) throw new Error(message.error.message);
+  if (message.result?.isError) throw new Error(message.result.content?.find((entry) => entry.type === 'text')?.text || 'Recherche BODACC impossible.');
+  return message.result?.content || [];
+}
+
+function readHistory(content: McpContent[], siren: string): BodaccSearchResult {
+  const resourceText = content.find((entry) => entry.type === 'resource')?.resource?.text;
+  if (!resourceText) throw new Error('La réponse BODACC ne contient pas de données exploitables.');
+  const history = JSON.parse(resourceText) as { siren?: string; total_annonces?: number; alertes?: string[]; categories?: Record<string, Array<Record<string, unknown>>> };
+  const annonces = Object.values(history.categories || {}).flat().map((annonce) => ({
+    id: String(annonce.id || ''),
+    datePublication: String(annonce.date_parution || annonce.date || ''),
+    typeAvis: String(annonce.type_avis || annonce.type || ''),
+    familleAvis: String(annonce.famille_avis || ''),
+    commercant: String(annonce.commercant || ''),
+    ville: String(annonce.ville || ''),
+    tribunal: String(annonce.tribunal || ''),
+    jugement: String(annonce.jugement || ''),
+    acte: String(annonce.acte || ''),
+    url: String(annonce.url || ''),
+  }));
+  return { siren: history.siren || siren, total: Number(history.total_annonces || annonces.length), alertes: history.alertes || [], annonces };
+}
+
+function familyCode(announcement: BodaccAnnouncement): string {
+  const family = announcement.familleAvis.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLocaleLowerCase();
+  if (family.includes('depot') && family.includes('compte')) return 'dpc';
+  if (family.includes('modification')) return 'modification';
+  if (family.includes('creation')) return 'creation';
+  if (family.includes('radiation')) return 'radiation';
+  if (family.includes('conciliation')) return 'conciliation';
+  if (family.includes('retablissement professionnel')) return 'retablissement_professionnel';
+  if (family.includes('procedure') && family.includes('collective')) return 'collective';
+  if (family.includes('vente') || family.includes('cession')) return 'vente';
+  if (family.includes('immatriculation')) return 'immatriculation';
+  if (family.includes('divers')) return 'divers';
+  return 'inconnue';
+}
+
+function filterFamilies(result: BodaccSearchResult, requestedFamilies: string[] | null): BodaccSearchResult {
+  if (requestedFamilies === null) return result;
+  const families = [...new Set(requestedFamilies.filter((family) => BODACC_FAMILY_CODES.has(family)))];
+  if (families.length === BODACC_FAMILY_CODES.size) return result;
+  const annonces = result.annonces.filter((announcement) => families.includes(familyCode(announcement)));
+  return { ...result, total: annonces.length, annonces, alertes: result.alertes.filter((alert) => (alert.toLocaleLowerCase().includes('procedure') && families.includes('collective')) || (alert.toLocaleLowerCase().includes('radiation') && families.includes('radiation'))) };
+}
+
+async function searchBodacc(siren: string, siret: string, requestedFamilies: string[] | null): Promise<BodaccSearchResult> {
+  const normalized = normalizedSiren(siren, siret);
+  const response = await mcpCall('Tracking_BODACC', { siren: normalized, type_recherche: 'historique' });
+  return filterFamilies(readHistory(resultContent(response), normalized), requestedFamilies);
+}
+
+export function createBodaccSearchRouter() {
+  const router = express.Router();
+  router.post('/bodacc-search', async (request: Request, response: Response) => {
+    const siren = typeof request.body?.siren === 'string' ? request.body.siren : '';
+    const siret = typeof request.body?.siret === 'string' ? request.body.siret : '';
+    const families = Array.isArray(request.body?.families) ? request.body.families.filter((family: unknown): family is string => typeof family === 'string') : null;
+    try {
+      response.json(await searchBodacc(siren, siret, families));
+    } catch (error) {
+      response.status(502).json({ error: error instanceof Error ? error.message : 'Recherche BODACC impossible.' });
+    }
+  });
+  return router;
+}

package/server/piecemaker/company-search.test.ts

@@ -0,0 +1,26 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { parseSearchLine } from './company-search.js';
+
+test('company search accepts registry results without a legal form', () => {
+  assert.deepEqual(
+    parseSearchLine('- GENSIGHT BIOLOGICS | SIREN 751164757 | en activité | NAF 72.19Z | 74 RUE DU FBG ST ANTOINE 75012 PARIS 12'),
+    {
+      name: 'GENSIGHT BIOLOGICS',
+      siren: '751164757',
+      summary: 'en activité · NAF 72.19Z · 74 RUE DU FBG ST ANTOINE 75012 PARIS 12',
+    },
+  );
+});
+
+test('company search preserves a legal form in registry results', () => {
+  assert.deepEqual(
+    parseSearchLine('- GENSIGHT BIOLOGICS (SA) | SIREN 751164757 | en activité | NAF 72.19Z | 74 RUE DU FBG ST ANTOINE 75012 PARIS 12'),
+    {
+      name: 'GENSIGHT BIOLOGICS',
+      siren: '751164757',
+      summary: 'SA · en activité · NAF 72.19Z · 74 RUE DU FBG ST ANTOINE 75012 PARIS 12',
+    },
+  );
+});