feat(erp): manifeste d'exercice, rejeu à blanc, gardes manquantes, trunk réconcilié (#92)

Co-authored-by: Gabriel Radureau <[email protected]>

test/extractExercise.ts

@@ -0,0 +1,245 @@
+/*
+  Extrait d'une instance Dolibarr le MANIFESTE D'UN EXERCICE : la description
+  complète et ordonnée des faits qui le composent.
+
+  POURQUOI. Un exercice ouvert n'a d'engagement envers personne — aucun compte
+  déposé, aucune liasse, aucun FEC remis. Tant qu'il en va ainsi, une erreur de
+  MODÉLISATION (mauvais compte, auxiliaire manquant, libellé illisible) se
+  corrige mieux en rejouant depuis les pièces qu'en la contournant : la piste
+  d'audit fiable demande que l'écriture reflète sa pièce, et rejouer resserre ce
+  lien là où une rustine le distend.
+
+  Ce fichier ne fait que LIRE. Il produit le manifeste ; le rejeu est un autre
+  outil, et il ne s'exécute que sur une cible vierge.
+
+  CE QUI EST REJOUABLE, ET CE QUI NE L'EST PAS. La ligne de partage n'est pas
+  technique, elle est juridique :
+
+    rejouable  : factures fournisseur enregistrées, lignes bancaires, paiements
+                 divers, charges sociales, tiers — tout ce qui est interne ;
+    FIGÉ       : toute pièce déjà remise à un tiers (facture client ENVOYÉE,
+                 dépôt au greffe, déclaration transmise) et tout exercice clos.
+
+  Une facture partie chez le client existe chez lui : aucun rejeu ne l'efface.
+  Le manifeste les extrait quand même — il décrit l'exercice — mais les marque
+  `delivered: true`, et le rejeu devra les reproduire à l'identique plutôt que
+  les recalculer.
+
+  LE RÉFÉRENT DE VÉRIFICATION. Les mouvements bancaires sont la seule partie de
+  l'exercice qu'on ne peut pas réécrire : Qonto et Wise sont hors de Dolibarr.
+  Le manifeste les embarque donc intégralement, et le test d'acceptation d'un
+  rejeu est qu'ils soient retrouvés au centime et à la date.
+
+  Usage :
+    DENO_TLS_CA_STORE=system \
+    DOLIBARR_URL=https://erp.arcodange.lab DOLAPIKEY=$(cat test/....key) \
+      deno run -A test/extractExercise.ts --year 2026 --out manifest.json
+
+  `DENO_TLS_CA_STORE=system` n'est pas décoratif : les hôtes du lab portent un
+  certificat signé par une autorité interne, présente dans le trousseau système
+  mais absente du magasin que Deno embarque. Sans lui, `fetch` échoue sur
+  « invalid peer certificate: UnknownIssuer » — alors que curl et Playwright,
+  qui lisent le trousseau système, passent sans rien dire.
+*/
+import "load_dotenv";
+
+const argv = Deno.args;
+const pick = (f: string, d = "") => (argv.includes(f) ? argv[argv.indexOf(f) + 1] : d);
+
+const base = pick("--url", Deno.env.get("DOLIBARR_URL") ?? "https://erp.arcodange.lab");
+const key = Deno.env.get("DOLAPIKEY") ?? "";
+const year = Number(pick("--year", "2026"));
+const out = pick("--out", `manifest-${year}.json`);
+
+/**
+ * Pièces volontairement écartées du rejeu, avec leur motif.
+ *
+ * Une exclusion n'est légitime que si la pièce N'A JAMAIS ÉTÉ REMISE À UN TIERS.
+ * Le motif est consigné dans le manifeste : un auditeur doit pouvoir lire
+ * pourquoi une référence manque, sans avoir à le deviner ni à nous croire.
+ */
+const EXCLUSIONS: Record<string, string> = {
+  "FAC001-CL00001":
+    "Référence malformée (CL00001 au lieu de CL0001001) — défaut de configuration du masque. "
+    + "JAMAIS REMISE AU CLIENT : vérifié le 2026-08-14, aucune trace d'envoi ; KissMetrics a été "
+    + "facturé via Wise en février 2026, et le document qu'il détient référence FAC001-CL0001001. "
+    + "La séquence FAC reste continue (FAC001 à FAC008), la réémission portant elle aussi FAC001.",
+  "AVC001-CL0001001":
+    "Avoir émis le 24/02/2026 pour annuler FAC001-CL00001. Sans objet dès lors que la facture "
+    + "annulée n'a jamais quitté la société : il ne documentait qu'un faux pas interne, non un "
+    + "événement commercial. La séquence AVC devient vide.",
+};
+
+if (!key) {
+  console.error("DOLAPIKEY requis (lecture seule).");
+  Deno.exit(2);
+}
+
+async function api<T>(path: string): Promise<T | null> {
+  const r = await fetch(`${base}/api/index.php${path}`, { headers: { DOLAPIKEY: key } });
+  if (!r.ok) return null;
+  try {
+    return await r.json() as T;
+  } catch {
+    return null;
+  }
+}
+
+/** Dolibarr rend des epochs ; on les fige en ISO dans le fuseau du serveur. */
+const iso = (ts: unknown): string | null => {
+  const n = Number(ts);
+  if (!n) return null;
+  return new Date(n * 1000).toISOString().slice(0, 10);
+};
+
+const inYear = (ts: unknown) => {
+  const d = iso(ts);
+  return !!d && d.startsWith(String(year));
+};
+
+type Any = Record<string, unknown>;
+
+console.log(`source   : ${base}`);
+console.log(`exercice : ${year}\n`);
+
+// --- tiers ------------------------------------------------------------------
+const tiers = (await api<Any[]>("/thirdparties?limit=500") ?? []).map((t) => ({
+  id: t.id,
+  name: t.name,
+  code_client: t.code_client,
+  code_fournisseur: t.code_fournisseur,
+  client: t.client,
+  fournisseur: t.fournisseur,
+  country_id: t.country_id,
+  tva_intra: t.tva_intra,
+  code_compta: t.code_compta,
+  code_compta_fournisseur: t.code_compta_fournisseur,
+}));
+console.log(`tiers                 : ${tiers.length}`);
+
+// --- factures client --------------------------------------------------------
+// `delivered: true` : elles sont parties chez le client. Un rejeu les reproduit
+// à l'identique — référence, date, montant — il ne les recalcule pas.
+const invoices = [];
+const excluded: Any[] = [];
+for (const f of await api<Any[]>("/invoices?limit=500") ?? []) {
+  if (!inYear(f.date)) continue;
+  const motif = EXCLUSIONS[String(f.ref)];
+  if (motif) {
+    excluded.push({ ref: f.ref, date: iso(f.date), total_ttc: f.total_ttc, motif });
+    continue;
+  }
+  const payments = await api<Any[]>(`/invoices/${f.id}/payments`) ?? [];
+  invoices.push({
+    ref: f.ref,
+    socid: f.socid,
+    date: iso(f.date),
+    date_lim_reglement: iso(f.date_lim_reglement),
+    type: f.type,
+    total_ht: f.total_ht,
+    total_tva: f.total_tva,
+    total_ttc: f.total_ttc,
+    multicurrency_code: f.multicurrency_code,
+    statut: f.statut,
+    paye: f.paye,
+    delivered: true,
+    lines: (f.lines as Any[] ?? []).map((l) => ({
+      desc: l.desc, subprice: l.subprice, qty: l.qty, tva_tx: l.tva_tx, product_type: l.product_type,
+    })),
+    payments: payments.map((p) => ({ amount: p.amount, type: p.type, date: p.date, ref: p.ref })),
+  });
+}
+console.log(`factures client       : ${invoices.length}  (figées — déjà remises au client)`);
+for (const e of excluded) console.log(`   ⊘ exclue : ${e.ref} (${e.total_ttc} EUR) — ${String(e.motif).slice(0, 72)}…`);
+
+// --- factures fournisseur ---------------------------------------------------
+const supplierInvoices = [];
+for (const f of await api<Any[]>("/supplierinvoices?limit=500") ?? []) {
+  if (!inYear(f.date)) continue;
+  const payments = await api<Any[]>(`/supplierinvoices/${f.id}/payments`) ?? [];
+  supplierInvoices.push({
+    ref: f.ref,
+    ref_supplier: f.ref_supplier,
+    socid: f.socid,
+    date: iso(f.date),
+    total_ht: f.total_ht,
+    total_tva: f.total_tva,
+    total_ttc: f.total_ttc,
+    statut: f.statut,
+    paye: f.paye,
+    lines: (f.lines as Any[] ?? []).map((l) => ({
+      desc: l.desc, subprice: l.subprice, qty: l.qty, tva_tx: l.tva_tx, product_type: l.product_type,
+    })),
+    payments: payments.map((p) => ({ amount: p.amount, type: p.type, date: p.date, ref: p.ref })),
+  });
+}
+console.log(`factures fournisseur  : ${supplierInvoices.length}`);
+
+// --- comptes et mouvements bancaires ---------------------------------------
+// LE RÉFÉRENT. Tout le reste se vérifie contre ces lignes.
+const accounts = [];
+let bankLineCount = 0;
+for (const a of await api<Any[]>("/bankaccounts") ?? []) {
+  const lines = (await api<Any[]>(`/bankaccounts/${a.id}/lines?limit=1000`) ?? [])
+    .map((l) => ({
+      date: iso(l.datev ?? l.dateo),
+      amount: Number(l.amount),
+      label: l.label,
+      // Les libellés générés par Dolibarr — « SupplierInvoicePayment »,
+      // « CustomerInvoicePayment » — traversent le grand livre tels quels et y
+      // sont illisibles. Le rejeu doit les remplacer par le libellé de la pièce.
+      generic_label: /^\(?(Customer|Supplier)InvoicePayment\)?$/.test(String(l.label ?? "")),
+      num_releve: l.num_releve,
+    }))
+    .filter((l) => l.date)
+    .sort((x, y) => String(x.date).localeCompare(String(y.date)));
+  bankLineCount += lines.length;
+  accounts.push({
+    id: a.id,
+    label: a.label,
+    ref: a.ref,
+    account_number: a.account_number,
+    accountancy_journal: a.accountancy_journal,
+    currency_code: a.currency_code,
+    balance: Number(lines.reduce((s, l) => s + l.amount, 0).toFixed(2)),
+    lines,
+  });
+}
+console.log(`comptes bancaires     : ${accounts.length}  (${bankLineCount} mouvements — référent de vérification)`);
+
+const generics = accounts.flatMap((a) => a.lines).filter((l) => l.generic_label).length;
+
+const manifest = {
+  meta: {
+    exercice: year,
+    source: base,
+    extracted_at: new Date().toISOString(),
+    // Un exercice clos ne se rejoue pas : la clôture est la limite dure.
+    replayable: true,
+    note: "Manifeste d'exercice — description des faits, non des écritures comptables. "
+      + "Les factures client sont marquées delivered:true : elles existent chez le client "
+      + "et se reproduisent à l'identique, jamais ne se recalculent.",
+  },
+  exclusions: excluded,
+  anomalies: {
+    libelles_generiques: generics,
+    detail: generics
+      ? "lignes bancaires portant un libellé Dolibarr générique — à remplacer au rejeu"
+      : "aucune",
+  },
+  tiers,
+  invoices,
+  supplierInvoices,
+  accounts,
+};
+
+await Deno.writeTextFile(out, JSON.stringify(manifest, null, 2));
+
+const totalClient = invoices.reduce((s, f) => s + Number(f.total_ttc ?? 0), 0);
+const totalFourn = supplierInvoices.reduce((s, f) => s + Number(f.total_ttc ?? 0), 0);
+console.log(`\n--- récapitulatif ---`);
+console.log(`  produits facturés   : ${totalClient.toFixed(2)} EUR`);
+console.log(`  achats facturés     : ${totalFourn.toFixed(2)} EUR`);
+for (const a of accounts) console.log(`  ${String(a.label).padEnd(32)} ${a.balance.toFixed(2)} EUR`);
+console.log(`  libellés génériques : ${generics}  ← à corriger au rejeu`);
+console.log(`\nmanifeste écrit : ${out}`);

test/main.ts

@@ -2,6 +2,7 @@ import "load_dotenv";
 import { chromium } from "playwright";
 import initialSetup from "./scripts/admin/initialSetup.ts";
 import login from "./scripts/login.ts";
+import { assertSandbox } from "./scripts/guard.ts";
 import companySetup, { Company } from "./scripts/admin/companySetup.ts";
 import path from "node:path";
 import displaySetup from "./scripts/admin/displaySetup.ts";
@@ -10,8 +11,14 @@ import moduleSetup from "./scripts/admin/moduleSetup.ts";
 /*
   Initialisation
 */
-const dolibarrAddress = Deno.env.get("DOLIBARR_ADDRESS") ||
-  "https://erp.arcodange.duckdns.org";
+// GARDE D'HÔTE. main.ts pilote l'ASSISTANT D'INSTALLATION (`/install/`) : c'est
+// le script le plus destructeur du dépôt. Pointé sur la production avec
+// l'environnement ambiant — et `test/.env` porte justement DOLIBARR_ADDRESS sur
+// la PRODUCTION — il relancerait l'installeur sur l'ERP réel.
+// assertSandbox() n'autorise que le bac à sable, sauf double opt-in explicite
+// (ARCO_ALLOW_PRODUCTION + ARCO_PROD_CONFIRM) pour l'installation initiale d'un
+// nouvel environnement, qui reste un geste d'opérateur.
+const dolibarrAddress = assertSandbox();
 const debug = true;
 const DBpassword = Deno.env.get("DOLI_DB_PASSWORD") || "undefined";
 const adminCredentials = {
@@ -20,7 +27,7 @@ const adminCredentials = {
 };
 
 const rootFolderPath = Deno.env.get("ROOT_FOLDER") ||
-  "/Users/gabrielradureau/Desktop/ARCODANGE/erp";
+  "/Users/gabrielradureau/Work/Arcodange/erp";
 const imgFolderPath = Deno.env.get("IMG_FOLDER") ||
   path.join(rootFolderPath, "static/img");
 const configFolderPath = Deno.env.get("CONFIG_FOLDER") ||
@@ -71,7 +78,7 @@ const globalCtx = {
 
 try {
   // await displaySetup.setupDisplay(globalCtx);
-  await moduleSetup.configureModule(globalCtx, {moduleName: 'TIERS' ,enabled: false, onConfiguration: async () => {
+  await moduleSetup.configureModule(globalCtx, {moduleName: 'TIERS' , enabled: true, onConfiguration: async () => {
     await globalCtx.page.screenshot({path: 'save.png'})
   }});
 } catch (error) {

test/replayExercise.ts

@@ -0,0 +1,151 @@
+/*
+  Rejeu d'un exercice à partir de son manifeste — pour l'instant EN LECTURE SEULE.
+
+  CE QU'IL FAIT AUJOURD'HUI. Il calcule l'état que produirait le rejeu, corrections
+  comprises, et le confronte au RÉFÉRENT : les mouvements bancaires. Qonto et Wise
+  sont hors de Dolibarr, on ne peut pas les réécrire ; si le rejeu les reproduit au
+  centime et à la date, il décrit le même exercice. C'est le seul test qui vaille.
+
+  CE QU'IL NE FAIT PAS ENCORE, et pourquoi. Un rejeu en écriture suppose une
+  instance VIERGE. `ops/sandbox/sandbox-lifecycle.sh` ne sait que `refresh-from-prod`
+  — un re-seed iso-prod, qui réimporte précisément les défauts qu'on veut corriger.
+  Écrire le rejeu sans cette capacité produirait des doublons, pas une reconstruction.
+  La capacité manquante est donc un préalable, pas un détail d'implémentation.
+
+  LES CORRECTIONS QUE LE REJEU APPLIQUERAIT. Elles sont déclarées ici, pas éparpillées
+  dans le code : chacune nomme le défaut, sa cause et son remède. C'est ce que lira
+  un comptable repreneur pour comprendre pourquoi le livre reconstruit diffère de
+  l'ancien.
+
+  Usage :
+    DENO_TLS_CA_STORE=system DOLAPIKEY=… \
+      deno run -A test/replayExercise.ts --manifest …/manifest.json [--url …]
+*/
+import "load_dotenv";
+
+const argv = Deno.args;
+const pick = (f: string, d = "") => (argv.includes(f) ? argv[argv.indexOf(f) + 1] : d);
+
+const manifestPath = pick("--manifest", "manifest-2026.json");
+const base = pick("--url", Deno.env.get("DOLIBARR_URL") ?? "https://erp.arcodange.lab");
+const key = Deno.env.get("DOLAPIKEY") ?? "";
+
+type Any = Record<string, unknown>;
+type Line = { date: string; amount: number; label: string; generic_label: boolean };
+type Account = { id: string; label: string; balance: number; lines: Line[] };
+
+const manifest = JSON.parse(await Deno.readTextFile(manifestPath)) as {
+  meta: Any; exclusions: Any[]; accounts: Account[];
+  invoices: Any[]; supplierInvoices: Any[]; tiers: Any[];
+};
+
+/**
+ * Corrections que le rejeu appliquerait. Déclaratives : le défaut, sa cause, son
+ * remède. Une correction sans cause écrite est une réécriture silencieuse.
+ */
+const CORRECTIONS = [
+  {
+    id: "libelles-generiques",
+    defaut: "20 des 37 mouvements bancaires portent « (SupplierInvoicePayment) » ou "
+      + "« (CustomerInvoicePayment) », libellés générés par Dolibarr",
+    cause: "aucun libellé n'est fourni à l'enregistrement du règlement ; Dolibarr retombe "
+      + "sur une clé de traduction",
+    remede: "libeller chaque règlement d'après sa pièce — référence du fournisseur ou du client, "
+      + "objet, période",
+    portee: "grand livre : ces libellés le traversent tels quels et y sont illisibles pour un "
+      + "repreneur comme pour un inspecteur",
+  },
+  {
+    id: "auxiliaire-indemnites",
+    defaut: "les 7 paiements divers d'indemnité d'occupation ne se journalisent pas",
+    cause: "compte auxiliaire vide sur la ligne de charge ; le journal de banque exige une "
+      + "contrepartie identifiée (« Tiers inconnu et code comptable auxiliaire non défini »)",
+    remede: "renseigner subledger_account = 455110 — vérifié en sandbox, l'écriture journalise",
+    portee: "sans cela le compte courant reste hors du grand livre : 1 483,23 EUR absents",
+  },
+  {
+    id: "tva-ovh-non-deductible",
+    defaut: "FAF2025001 enregistrée 6,08 HT + 1,22 TVA, la TVA figurant en déductible "
+      + "(CA3 ligne 20, période 2025-10)",
+    cause: "facture émise au nom personnel du fondateur, la société n'étant pas immatriculée ; "
+      + "une facture adressée à un particulier n'ouvre aucun droit à déduction",
+    remede: "enregistrer 7,30 EUR TTC au taux 0 — la charge est reprise pour son montant TTC "
+      + "(décision n° 3, reprise L. 210-6)",
+    portee: "TVA déductible de l'exercice : 353,76 → 352,54 EUR. Aucune déclaration déposée "
+      + "(CA12 annuelle, exercice clos le 31/12) — la correction ne coûte rien",
+  },
+] as const;
+
+async function api<T>(path: string): Promise<T | null> {
+  const r = await fetch(`${base}/api/index.php${path}`, { headers: { DOLAPIKEY: key } });
+  if (!r.ok) return null;
+  try { return await r.json() as T; } catch { return null; }
+}
+
+const iso = (ts: unknown): string | null => {
+  const n = Number(ts);
+  return n ? new Date(n * 1000).toISOString().slice(0, 10) : null;
+};
+
+console.log(`manifeste : ${manifestPath}`);
+console.log(`exercice  : ${manifest.meta.exercice}`);
+console.log(`cible     : ${base}\n`);
+
+// --- 1. le référent : la banque ---------------------------------------------
+console.log("=== CONTRÔLE BANCAIRE — le rejeu reproduit-il les mouvements ? ===\n");
+
+let totalAttendu = 0, totalTrouve = 0, ecarts = 0;
+for (const a of manifest.accounts) {
+  const live = (await api<Any[]>(`/bankaccounts/${a.id}/lines?limit=1000`) ?? [])
+    .map((l) => ({ date: iso(l.datev ?? l.dateo), amount: Number(l.amount) }))
+    .filter((l) => l.date);
+
+  // Appariement par (date, montant) : ce que la banque impose, et rien de plus.
+  // Le libellé ne participe PAS à l'appariement — c'est justement ce qu'on corrige.
+  const reste = [...live];
+  const manquants: Line[] = [];
+  for (const m of a.lines) {
+    const i = reste.findIndex((l) => l.date === m.date && Math.abs(l.amount - m.amount) < 0.005);
+    if (i >= 0) reste.splice(i, 1); else manquants.push(m);
+  }
+  totalAttendu += a.lines.length;
+  totalTrouve += a.lines.length - manquants.length;
+  ecarts += manquants.length + reste.length;
+
+  const verdict = manquants.length === 0 && reste.length === 0 ? "conforme" : "ÉCART";
+  console.log(`  ${a.label.padEnd(32)} ${String(a.lines.length).padStart(3)} mouvements   ${a.balance.toFixed(2).padStart(10)} EUR   ${verdict}`);
+  for (const m of manquants) console.log(`      manquant à la cible : ${m.date}  ${m.amount.toFixed(2)}  ${m.label}`);
+  for (const r of reste) console.log(`      en trop à la cible  : ${r.date}  ${r.amount.toFixed(2)}`);
+}
+
+console.log(`\n  ${totalTrouve}/${totalAttendu} mouvements appariés à la date et au centime`
+  + (ecarts ? `  —  ${ecarts} écart(s)` : "  —  aucun écart"));
+
+// --- 2. ce que le rejeu changerait ------------------------------------------
+console.log("\n=== CORRECTIONS QUE LE REJEU APPLIQUERAIT ===\n");
+for (const c of CORRECTIONS) {
+  console.log(`  ▸ ${c.id}`);
+  console.log(`      défaut : ${c.defaut}`);
+  console.log(`      cause  : ${c.cause}`);
+  console.log(`      remède : ${c.remede}`);
+  console.log(`      portée : ${c.portee}\n`);
+}
+
+// --- 3. ce que le rejeu écarterait ------------------------------------------
+console.log("=== PIÈCES ÉCARTÉES ===\n");
+for (const e of manifest.exclusions) {
+  console.log(`  ⊘ ${e.ref}  (${Number(e.total_ttc).toFixed(2)} EUR, ${e.date})`);
+  console.log(`      ${String(e.motif).replace(/(.{92})/g, "$1\n      ")}\n`);
+}
+
+// --- 4. verdict --------------------------------------------------------------
+const genericCount = manifest.accounts.flatMap((a) => a.lines).filter((l) => l.generic_label).length;
+console.log("=== VERDICT ===\n");
+console.log(`  manifeste complet vis-à-vis de la banque : ${ecarts === 0 ? "OUI" : "NON — " + ecarts + " écart(s)"}`);
+console.log(`  corrections à appliquer                  : ${CORRECTIONS.length}`);
+console.log(`  libellés à réécrire                      : ${genericCount}`);
+console.log(`  pièces écartées                          : ${manifest.exclusions.length}`);
+console.log(`\n  Le rejeu EN ÉCRITURE reste bloqué : il exige une instance vierge, que`);
+console.log(`  sandbox-lifecycle.sh ne sait pas produire (refresh-from-prod uniquement).`);
+
+Deno.exit(ecarts === 0 ? 0 : 1);