@piecemaker-legal/piecemaker 1.0.6 → 1.0.7

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',
+    },
+  );
+});

package/server/piecemaker/company-search.ts

@@ -0,0 +1,183 @@
+import express, { type Request, type Response } from 'express';
+
+const REGISTRE_PUBLIC_MCP_URL = 'https://registre-public.com/api/mcp';
+const MCP_PROTOCOL_VERSION = '2025-03-26';
+const MCP_TIMEOUT_MS = 20_000;
+
+type JsonRpcPayload = {
+  result?: {
+    content?: Array<{ type?: string; text?: string }>;
+    isError?: boolean;
+  };
+  error?: { message?: string };
+};
+
+export type CompanyDirector = { name: string; role: string };
+
+export type CompanySearchFields = {
+  legalName: string;
+  legalForm: string;
+  status: string;
+  siren: string;
+  siret: string;
+  vat: string;
+  legalFormCode: string;
+  naf: string;
+  creationDate: string;
+  category: string;
+  address: string;
+  directors: CompanyDirector[];
+  finances: string[];
+  source: string;
+};
+
+export type CompanySearchResult = {
+  name: string;
+  siren: string;
+  summary: string;
+  url: string;
+  details: string;
+  fields: CompanySearchFields;
+};
+
+function parseMcpPayload(body: string): JsonRpcPayload {
+  const trimmed = body.trim();
+  if (trimmed.startsWith('{')) return JSON.parse(trimmed) as JsonRpcPayload;
+  const payloads = trimmed
+    .split(/\r?\n/)
+    .filter((line) => line.startsWith('data:'))
+    .map((line) => line.slice(5).trim())
+    .filter(Boolean)
+    .map((line) => JSON.parse(line) as JsonRpcPayload);
+  const payload = payloads.at(-1);
+  if (!payload) throw new Error('Réponse PERS_MORALE_1 invalide.');
+  return payload;
+}
+
+async function mcpRequest(id: number, method: string, params: Record<string, unknown>, sessionId?: string): Promise<{ payload: JsonRpcPayload; sessionId?: string }> {
+  const response = await fetch(REGISTRE_PUBLIC_MCP_URL, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json, text/event-stream',
+      'Content-Type': 'application/json',
+      ...(sessionId ? { 'Mcp-Session-Id': sessionId } : {}),
+    },
+    body: JSON.stringify({ jsonrpc: '2.0', id, method, params }),
+    signal: AbortSignal.timeout(MCP_TIMEOUT_MS),
+  });
+  const body = await response.text();
+  if (!response.ok) throw new Error(`Registre Public a répondu ${response.status}.`);
+  const payload = parseMcpPayload(body);
+  if (payload.error?.message) throw new Error(payload.error.message);
+  return { payload, sessionId: response.headers.get('mcp-session-id') || sessionId };
+}
+
+async function mcpNotification(method: string, params: Record<string, unknown>, sessionId?: string): Promise<void> {
+  const response = await fetch(REGISTRE_PUBLIC_MCP_URL, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json, text/event-stream',
+      'Content-Type': 'application/json',
+      ...(sessionId ? { 'Mcp-Session-Id': sessionId } : {}),
+    },
+    body: JSON.stringify({ jsonrpc: '2.0', method, params }),
+    signal: AbortSignal.timeout(MCP_TIMEOUT_MS),
+  });
+  if (!response.ok) throw new Error(`Registre Public a répondu ${response.status}.`);
+}
+
+function resultText(payload: JsonRpcPayload): string {
+  const text = payload.result?.content?.filter((entry) => entry.type === 'text' && typeof entry.text === 'string').map((entry) => entry.text).join('\n').trim();
+  if (!text || payload.result?.isError) throw new Error('Registre Public n’a renvoyé aucun résultat exploitable.');
+  return text;
+}
+
+function lineValue(text: string, label: string): string {
+  const line = text.split('\n').find((entry) => entry.startsWith(label));
+  return line ? line.slice(label.length).trim() : '';
+}
+
+export function parseSearchLine(line: string): { name: string; siren: string; summary: string } | null {
+  const match = /^-\s+(.+?)(?:\s+\(([^)]+)\))?\s+\|\s+SIREN\s+(\d{9})\s+\|\s+(.+?)\s+\|\s+NAF\s+([^|]+)\s+\|\s+(.+)$/.exec(line.trim());
+  if (!match) return null;
+  return { name: match[1].trim(), siren: match[3], summary: [match[2]?.trim(), match[4].trim(), `NAF ${match[5].trim()}`, match[6].trim()].filter(Boolean).join(' · ') };
+}
+
+function parseDirectors(text: string): CompanyDirector[] {
+  const start = text.indexOf('Dirigeants:');
+  if (start < 0) return [];
+  const block = text.slice(start + 'Dirigeants:'.length).split(/\n(?=Finances\b|$)/)[0];
+  return block.split('\n').map((line) => /^-\s+(.+?)\s+\(([^)]+)\)$/.exec(line.trim())).filter((match): match is RegExpExecArray => Boolean(match)).map((match) => ({ name: match[1].trim(), role: match[2].trim() }));
+}
+
+function parseCompanyDetails(text: string, fallback: { name: string; siren: string }): CompanySearchFields {
+  const heading = /^#\s+(.+?)\s+\(([^)]+)\)\s+\(([^)]+)\)/m.exec(text);
+  const formAndActivity = lineValue(text, 'Forme juridique (code) :');
+  const [legalFormCode, nafPart] = formAndActivity.split('|').map((value) => value.trim());
+  const creation = lineValue(text, 'Création :');
+  const [creationDate, categoryPart] = creation.split('|').map((value) => value.trim());
+  return {
+    legalName: heading?.[1]?.trim() || fallback.name,
+    legalForm: '',
+    status: heading?.[3]?.trim() || '',
+    siren: lineValue(text, 'SIREN :').split('|')[0].trim() || fallback.siren,
+    siret: (lineValue(text, 'SIREN :').match(/SIRET siège\s*:\s*([^|]+)/)?.[1] || '').trim(),
+    vat: lineValue(text, 'N° TVA intracommunautaire :'),
+    legalFormCode: legalFormCode || '',
+    naf: nafPart?.replace(/^NAF\s*:\s*/, '') || '',
+    creationDate: creationDate || '',
+    category: categoryPart?.replace(/^Catégorie\s*:\s*/, '') || '',
+    address: lineValue(text, 'Adresse du siège :'),
+    directors: parseDirectors(text),
+    finances: text.split('\n').filter((line) => line.startsWith('Finances ')).map((line) => line.trim()),
+    source: lineValue(text, 'Fiche web :'),
+  };
+}
+
+async function callTool(tool: string, args: Record<string, unknown>): Promise<string> {
+  let sessionId: string | undefined;
+  const initialized = await mcpRequest(1, 'initialize', {
+    protocolVersion: MCP_PROTOCOL_VERSION,
+    capabilities: {},
+    clientInfo: { name: 'piecemaker-dossier', version: '0.1.0' },
+  });
+  sessionId = initialized.sessionId;
+  await mcpNotification('notifications/initialized', {}, sessionId);
+  const result = await mcpRequest(2, 'tools/call', { name: tool, arguments: args }, sessionId);
+  return resultText(result.payload);
+}
+
+async function searchCompanies(query: string): Promise<CompanySearchResult[]> {
+  const searchText = await callTool('rechercher_entreprise', { query });
+  const candidates = searchText.split('\n').map(parseSearchLine).filter((entry): entry is { name: string; siren: string; summary: string } => Boolean(entry));
+  const results = await Promise.all(candidates.map(async (candidate) => {
+    const details = await callTool('fiche_entreprise', { siren: candidate.siren });
+    const fields = parseCompanyDetails(details, candidate);
+    return {
+      name: fields.legalName || candidate.name,
+      siren: fields.siren || candidate.siren,
+      summary: candidate.summary,
+      url: fields.source,
+      details,
+      fields,
+    };
+  }));
+  return results;
+}
+
+export function createCompanySearchRouter() {
+  const router = express.Router();
+  router.post('/company-search', async (request: Request, response: Response) => {
+    const query = typeof request.body?.query === 'string' ? request.body.query.trim().slice(0, 200) : '';
+    if (!query) {
+      response.status(400).json({ error: 'Un nom ou un SIREN est requis.' });
+      return;
+    }
+    try {
+      response.json({ query, results: await searchCompanies(query) });
+    } catch (error) {
+      response.status(502).json({ error: error instanceof Error ? error.message : 'Recherche Registre Public impossible.' });
+    }
+  });
+  return router;
+}

package/server/piecemaker/index.ts

@@ -6,6 +6,7 @@ import type { Router } from 'express';
 import { providerRuntimeService, sessionsService } from '@/modules/providers/index.js';
 import { findApplicationRoot, getModuleDirectory } from '@/shared/utils.js';
 
+
 import { startRequiredAnonymizer } from './anonymizer/lifecycle.js';
 import { createCitationStore } from './harness/citation-store.js';
 import { installChatCitationHarness } from './harness/chat-harness.js';
@@ -13,6 +14,8 @@ import { createCitationsRouter } from './harness/citations.routes.js';
 import { startLibraryBackend, installLibraryRuntime } from './library/index.js';
 import { createKnowledgeBackend } from './knowledge/index.js';
 import { createTimesheetBackend } from './timesheet/index.js';
+import { createCompanySearchRouter } from './company-search.js';
+import { createBodaccSearchRouter } from './bodacc-search.js';
 
 /**
  * Point d'entrée PieceMaker. Les modules de `server/piecemaker/vendor/` sont du
@@ -35,11 +38,12 @@ type PieceMakerRuntimeStatus = {
 type PieceMakerVendorModule = {
   createPieceMakerRouter(options?: { getRuntimeStatus?: () => PieceMakerRuntimeStatus; anonymizer?: unknown }): Router;
   piecemakerHome(): string;
+  stopOriginalsJobs(): Promise<void>;
 };
 
 const vendor = createRequire(import.meta.url)(routerPath) as PieceMakerVendorModule;
 
-export const { piecemakerHome } = vendor;
+export const { piecemakerHome, stopOriginalsJobs } = vendor;
 const { createAnonymizerService } = createRequire(import.meta.url)(path.join(applicationRoot, 'server/piecemaker/anonymizer/service.cjs'));
 const anonymizer = createAnonymizerService({ homeDir: piecemakerHome(), required: true });
 const ensureProxy = await startRequiredAnonymizer(anonymizer);
@@ -56,7 +60,9 @@ export function createPieceMakerRouter(options: { getRuntimeStatus?: () => Piece
     try { sessionsService.getSessionDetailsById(id); return true; } catch { return false; }
   }));
   router.use(timesheet);
-  router.use(knowledge);
+  router.use(knowledge.router);
+  router.use(createCompanySearchRouter());
+  router.use(createBodaccSearchRouter());
   return router;
 }
 export type { PieceMakerRuntimeStatus };

package/server/piecemaker/knowledge/index.ts

@@ -3,6 +3,7 @@ import express from 'express';
 import { getConnection, projectsDb } from '@/modules/database/index.js';
 
 import { KnowledgeStore } from '../../../plugins/piecemaker-dossier/src/knowledge.js';
+
 import { createKnowledgePipeline } from './pipeline.js';
 import { createKnowledgeRouter } from './routes.js';
 import { createKnowledgeService } from './service.js';
@@ -10,13 +11,17 @@ import { createKnowledgeService } from './service.js';
 export function createKnowledgeBackend(applicationRoot: string) {
   const router = express.Router();
   let knowledgeRouter: express.Router | null = null;
+  let store: KnowledgeStore | null = null;
+  const getStore = () => {
+    if (!store) store = new KnowledgeStore(getConnection());
+    return store;
+  };
   router.use((request, response, next) => {
     if (!knowledgeRouter) {
-      const store = new KnowledgeStore(getConnection());
-      const pipeline = createKnowledgePipeline({ applicationRoot, projects: projectsDb, store });
-      knowledgeRouter = createKnowledgeRouter(createKnowledgeService(store, projectsDb, pipeline));
+      const pipeline = createKnowledgePipeline({ applicationRoot, projects: projectsDb, store: getStore() });
+      knowledgeRouter = createKnowledgeRouter(createKnowledgeService(getStore(), projectsDb, pipeline));
     }
     knowledgeRouter(request, response, next);
   });
-  return router;
+  return { router };
 }