@roomi-fields/grillhouse 0.0.0-stage → 0.23.1

package/scripts/dernier-vert.mjs

@@ -0,0 +1,208 @@
+// The last green of a branch: the tree of the last pass of `npm run verifier` green on every
+// package (scripts/verifier.mjs), against which the next pass measures itself, as
+// `vitest --changed <ref>` and `jest --onlyChanged` play the tests a change reaches, and Bazel
+// keeps by target the result of a test whose inputs did not move.
+//
+// - It lives in `<git common dir>/grillhouse/dernier-vert/<branche>.json`, one per branch, so that
+//   each copy (worktree) of a ticket keeps its own and no copy replaces another's or main's:
+//   `{ commit, arbre }`, HEAD at the start of that pass and the tree of the working tree then, the
+//   files git ignores left out, HEAD and the index untouched (a copy of the index, every file added
+//   to it, `git add -A`, written as a tree, as the circuit keeps a lot). A pass on a copy whose lot
+//   is not committed thus keeps what it played.
+// - A pass measures itself against the last green of its branch when it counts, else against
+//   main's, the branch of the main tree (HEAD of git's common directory), as `vitest --changed
+//   <ref>` and Bazel measure against the last green build of the same branch: the final pass of a
+//   ticket relaunched plays what changed since the copy's last green, not since main's. A HEAD
+//   detached (the queue's replay onto main, scripts/integration/file.mjs) reads and keeps main's.
+// - A last green counts when its commit is an ancestor of HEAD (or HEAD) and its tree is still in
+//   the repository. Then the changes are the files that differ between its tree and the tree of the
+//   working tree now (`git diff --raw --no-renames`): the files changed or added, and those
+//   removed. Any two trees compare: the ancestry keeps the measure to the history it belongs to.
+// - No last green counts without git, before the first commit, and while a submodule differs
+//   from the commit its parent records (its files changed, or its HEAD moved) or the changes
+//   reach a submodule: git's tree holds a submodule's commit, not its files. The pass is then
+//   complete, and keeps no green.
+// - The changes go to Vitest in a file that the variable `GRILLHOUSE_CHANGEMENTS` names
+//   (scripts/vitest-config/changements.mjs, which reads them in each package); the file lies in a
+//   temporary directory of its own, which the pass removes at its end.
+// - `npm test` measures itself against the last green under the circuit's mark,
+//   `GRILLHOUSE_DEPUIS_LE_VERT` (scripts/tests.mjs, scripts/circuit.mjs); it never keeps one.
+import { spawnSync } from 'node:child_process';
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { CHANGEMENTS } from './vitest-config/changements.mjs';
+
+export const DEPUIS_LE_VERT = 'GRILLHOUSE_DEPUIS_LE_VERT';
+const SHA = /^[0-9a-f]{40,64}$/;
+
+const git = (racine, args, env = process.env) =>
+  spawnSync('git', ['-C', racine, ...args], {
+    encoding: 'utf8',
+    env,
+    maxBuffer: 256 * 1024 * 1024,
+  });
+const sortie = (racine, args, env) => {
+  const r = git(racine, args, env);
+  return r.status === 0 ? r.stdout.trim() : null;
+};
+
+// The file of the last green of the branch <branche> of the repository at <racine>, null out of
+// git.
+function fichierDuVert(racine, branche) {
+  const commun = sortie(racine, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  return commun ? path.join(commun, 'grillhouse', 'dernier-vert', `${branche}.json`) : null;
+}
+
+// Main, the branch of the main tree of the repository at <racine> (HEAD of git's common
+// directory); null when that tree is detached.
+function brancheDeMain(racine) {
+  const commun = sortie(racine, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  return commun
+    ? sortie(racine, [`--git-dir=${commun}`, 'symbolic-ref', '--short', '-q', 'HEAD'])
+    : null;
+}
+
+// Whether a submodule of the repository at <racine> differs from the commit its parent records.
+function sousModuleModifie(racine) {
+  const r = git(racine, ['status', '--porcelain=v2', '-z', '--ignore-submodules=none']);
+  if (r.status !== 0) return true;
+  // An entry of a changed path: `1 <XY> <sub> …` (or `2` for a rename), <sub> `S<c><m><u>` for a
+  // submodule whose commit, tracked files or untracked files changed, `N...` for any other path.
+  return r.stdout.split('\0').some(e => /^[12] \S+ S/.test(e));
+}
+
+// The state of the repository at <racine> as it stands: `{ racine, commit, arbre, branche, main }`,
+// its top (its real path), HEAD, the tree of its working tree, the branch of HEAD (null when
+// detached) and main (brancheDeMain); `{ raison }` when no last green can count.
+function etatDuDepot(racine) {
+  const haut = sortie(racine, ['rev-parse', '--show-toplevel']);
+  if (!haut) return { raison: 'hors de git' };
+  const top = realpathSync(haut);
+  const commit = sortie(top, ['rev-parse', '--verify', '-q', 'HEAD^{commit}']);
+  if (!commit) return { raison: 'aucun commit' };
+  if (sousModuleModifie(top)) return { raison: 'un sous-module diffère de son commit' };
+  const dir = mkdtempSync(path.join(os.tmpdir(), 'grillhouse-vert-'));
+  try {
+    const index = path.join(dir, 'index');
+    const reel = sortie(top, ['rev-parse', '--path-format=absolute', '--git-path', 'index']);
+    const env = { ...process.env, GIT_INDEX_FILE: index };
+    if (reel && existsSync(reel)) copyFileSync(reel, index);
+    else if (git(top, ['read-tree', 'HEAD'], env).status !== 0) return { raison: 'git échoue' };
+    if (git(top, ['add', '-A'], env).status !== 0) return { raison: 'git échoue' };
+    const arbre = sortie(top, ['write-tree'], env);
+    if (!arbre) return { raison: 'git échoue' };
+    const branche = sortie(top, ['symbolic-ref', '--short', '-q', 'HEAD']);
+    return { racine: top, commit, arbre, branche, main: brancheDeMain(top) };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+// The last green that a pass in the state <etat> (etatDuDepot) measures itself against: its
+// branch's when it counts, else main's; `{ commit, arbre, branche }`, `{ raison }` when neither
+// counts (main's reason, or the branch's without main).
+function lireLeVert(etat) {
+  const branches = [...new Set([etat.branche, etat.main].filter(Boolean))];
+  let vert = { raison: 'aucun vert connu' };
+  for (const branche of branches) {
+    vert = lireLeVertDe(etat, branche);
+    if (!vert.raison) return vert;
+  }
+  return vert;
+}
+
+// The last green of the branch <branche>, when it counts for a pass in the state <etat>:
+// `{ commit, arbre, branche }`; `{ raison }` otherwise.
+function lireLeVertDe(etat, branche) {
+  const f = fichierDuVert(etat.racine, branche);
+  let v = null;
+  try {
+    v = JSON.parse(readFileSync(f, 'utf8'));
+  } catch {
+    return { raison: 'aucun vert connu' };
+  }
+  if (!SHA.test(v?.commit ?? '') || !SHA.test(v?.arbre ?? '')) {
+    return { raison: 'aucun vert connu' };
+  }
+  if (git(etat.racine, ['cat-file', '-e', `${v.arbre}^{tree}`]).status !== 0) {
+    return { raison: 'le dernier vert ne se lit plus' };
+  }
+  if (git(etat.racine, ['merge-base', '--is-ancestor', v.commit, etat.commit]).status !== 0) {
+    return { raison: 'le dernier vert n’est pas un ancêtre de HEAD' };
+  }
+  return { commit: v.commit, arbre: v.arbre, branche };
+}
+
+// Keeps <etat> (etatDuDepot) as the last green of its branch, of main when HEAD is detached.
+export function garderLeVert(etat) {
+  const branche = etat.branche ?? etat.main;
+  const f = branche ? fichierDuVert(etat.racine, branche) : null;
+  if (!f) return;
+  mkdirSync(path.dirname(f), { recursive: true });
+  writeFileSync(f, `${JSON.stringify({ commit: etat.commit, arbre: etat.arbre }, null, 2)}\n`);
+}
+
+// The files that differ between the trees <avant> and <apres> of the repository at <racine>:
+// `{ fichiers, supprimes, sousModules }`, each path from its top; null when git fails.
+function difference(racine, avant, apres) {
+  const r = git(racine, ['diff', '--raw', '--no-renames', '-z', avant, apres]);
+  if (r.status !== 0) return null;
+  const champs = r.stdout.split('\0');
+  const out = { fichiers: [], supprimes: [], sousModules: [] };
+  for (let i = 0; i + 1 < champs.length; i += 2) {
+    const [modeAvant, modeApres, , , statut] = champs[i].replace(/^:/, '').split(' ');
+    const f = champs[i + 1];
+    if (modeAvant === '160000' || modeApres === '160000') out.sousModules.push(f);
+    else if (statut === 'D') out.supprimes.push(f);
+    else out.fichiers.push(f);
+  }
+  return out;
+}
+
+// What a pass in <racine> measures itself against: `{ etat, env, ligne, retirer }`, the state to
+// keep once green (null when none can count), the variables to add to the pass's environment (the
+// changes since the last green, none for a complete pass), the line that says which, and the
+// function that removes the file of the changes. <tout> asks for the complete pass; the file lies
+// in <dans>, the base of the pass (scripts/vitest-config/base-de-passe.mjs), which a killed pass
+// leaves to the next one to sweep.
+export function mesure(racine, { tout = false, dans = os.tmpdir() } = {}) {
+  const etat = etatDuDepot(racine);
+  const complete = raison => ({
+    etat: etat.raison ? null : etat,
+    env: {},
+    ligne: `↳ passe complète : ${raison}.`,
+    retirer: () => {},
+  });
+  if (etat.raison) return complete(etat.raison);
+  if (tout) return complete('demandée');
+  const vert = lireLeVert(etat);
+  if (vert.raison) return complete(vert.raison);
+  const ch = difference(etat.racine, vert.arbre, etat.arbre);
+  if (!ch) return complete('git échoue');
+  if (ch.sousModules.length) {
+    return { ...complete(`un sous-module a changé (${ch.sousModules[0]})`), etat: null };
+  }
+  const dir = mkdtempSync(path.join(dans, 'grillhouse-changements-'));
+  const fichier = path.join(dir, 'changements.json');
+  writeFileSync(
+    fichier,
+    JSON.stringify({ racine: etat.racine, fichiers: ch.fichiers, supprimes: ch.supprimes })
+  );
+  const n = ch.fichiers.length + ch.supprimes.length;
+  return {
+    etat,
+    env: { [CHANGEMENTS]: fichier },
+    ligne: `↳ depuis le dernier vert de ${vert.branche} (${vert.commit.slice(0, 12)}, arbre ${vert.arbre.slice(0, 12)}) : ${n} fichier(s) changé(s) ; chaque paquet que Turborepo rejoue joue les tests que Vitest y relie.`,
+    retirer: () => rmSync(dir, { recursive: true, force: true }),
+  };
+}

package/scripts/dette.mjs

@@ -0,0 +1,181 @@
+// The known debt of the guards: the findings a project carries when it adopts the frame, written
+// and frozen in one file at its root, on the model of ESLint's bulk suppressions
+// (`eslint-suppressions.json`, `--suppress-all`, `--prune-suppressions`) and of betterer.
+//
+// The file `grillhouse-dette.json` holds, for each guard, each file and each rule, the count of
+// findings inscribed:
+//
+//   {
+//     "code-mort": { "src/a.ts": { "exports": { "count": 2 } } },
+//     "consommateurs": { "packages/b/docs/INTERFACE.md": { "usage-non-declare": { "count": 1 } } }
+//   }
+//
+// A finding is `{ fichier, regle, message }`, and its `ligne` when the guard knows it: its key is
+// the guard, the file and the rule (never a line number), its message what the guard prints. A finding without `fichier` or `regle` is never
+// inscribed: the guard refuses it every time (a generated file out of date, a measure that failed).
+//
+// - A guard passes when, for every key, the findings are no more than the inscribed count. A key
+//   whose count goes beyond refuses with all its findings, as ESLint reports them all, and a line
+//   naming the key, its count and the inscribed one.
+// - A key inscribed above what the guard finds is reported, without refusing, so it gets pruned.
+// - `GRILLHOUSE_DETTE=inscrire` writes the guard's whole section from what it finds (its debt of
+//   today); `GRILLHOUSE_DETTE=elaguer` lowers each inscribed count to what the guard finds and
+//   drops the keys at zero, never raising a count nor adding a key. Each guard then judges against
+//   the file it wrote. The npm scripts `grillhouse:dette:inscrire` and `grillhouse:dette:elaguer`
+//   run every guard so.
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { ecrireSarif } from './resultats.mjs';
+
+export const FICHIER = 'grillhouse-dette.json';
+// The environment variable that names the mode of a run: `inscrire` or `elaguer`.
+export const MODE = 'GRILLHOUSE_DETTE';
+const MODES = new Set(['inscrire', 'elaguer']);
+
+const inscriptible = c => Boolean(c.fichier && c.regle);
+
+// The findings counted per file and rule: Map fichier → Map regle → count.
+function compter(constats) {
+  const out = new Map();
+  for (const c of constats.filter(inscriptible)) {
+    if (!out.has(c.fichier)) out.set(c.fichier, new Map());
+    const parRegle = out.get(c.fichier);
+    parRegle.set(c.regle, (parRegle.get(c.regle) ?? 0) + 1);
+  }
+  return out;
+}
+
+// The section of a guard as written in the file, its keys sorted: { fichier: { regle: { count } } }.
+function section(comptes) {
+  const out = {};
+  for (const fichier of [...comptes.keys()].sort()) {
+    const regles = comptes.get(fichier);
+    out[fichier] = {};
+    for (const regle of [...regles.keys()].sort()) {
+      out[fichier][regle] = { count: regles.get(regle) };
+    }
+  }
+  return out;
+}
+
+// The debt written at <racine>: {} without the file. Throws, naming the file, when it is not JSON.
+export function lire(racine) {
+  const f = path.join(racine, FICHIER);
+  if (!existsSync(f)) return {};
+  try {
+    return JSON.parse(readFileSync(f, 'utf8'));
+  } catch (e) {
+    throw new Error(`${FICHIER} n'est pas un JSON lisible : ${e.message}`);
+  }
+}
+
+// <dette> with the section of <garde> replaced by what <constats> count; the guard leaves the file
+// when it finds nothing.
+export function inscrire(dette, garde, constats) {
+  const reste = { ...dette };
+  delete reste[garde];
+  const comptes = compter(constats);
+  return comptes.size ? { ...reste, [garde]: section(comptes) } : reste;
+}
+
+// <dette> with each count of <garde> lowered to what <constats> count, the keys at zero dropped;
+// a count never rises and no key is added.
+export function elaguer(dette, garde, constats) {
+  const { [garde]: ancienne = {}, ...reste } = dette;
+  const comptes = compter(constats);
+  const garde2 = new Map();
+  for (const [fichier, regles] of Object.entries(ancienne)) {
+    for (const [regle, { count }] of Object.entries(regles)) {
+      const n = Math.min(count, comptes.get(fichier)?.get(regle) ?? 0);
+      if (n === 0) continue;
+      if (!garde2.has(fichier)) garde2.set(fichier, new Map());
+      garde2.get(fichier).set(regle, n);
+    }
+  }
+  return garde2.size ? { ...reste, [garde]: section(garde2) } : reste;
+}
+
+// <constats> of <garde> judged against <dette>: `refus` the findings the guard refuses (those
+// without key, and every finding of a key beyond its count), `depasses` the keys beyond a non-zero
+// count, `corriges` the keys inscribed above what is found, `tus` the number of findings the debt
+// covers.
+export function juger(dette, garde, constats) {
+  const inscrite = dette[garde] ?? {};
+  const comptes = compter(constats);
+  const permis = (fichier, regle) => inscrite[fichier]?.[regle]?.count ?? 0;
+  const refus = constats.filter(
+    c => !inscriptible(c) || comptes.get(c.fichier).get(c.regle) > permis(c.fichier, c.regle)
+  );
+  const depasses = [];
+  for (const [fichier, regles] of comptes) {
+    for (const [regle, trouve] of regles) {
+      const inscrit = permis(fichier, regle);
+      if (inscrit > 0 && trouve > inscrit) depasses.push({ fichier, regle, trouve, inscrit });
+    }
+  }
+  const corriges = [];
+  for (const [fichier, regles] of Object.entries(inscrite)) {
+    for (const [regle, { count }] of Object.entries(regles)) {
+      const trouve = comptes.get(fichier)?.get(regle) ?? 0;
+      if (trouve < count) corriges.push({ fichier, regle, trouve, inscrit: count });
+    }
+  }
+  return { refus, depasses, corriges, tus: constats.length - refus.length };
+}
+
+// Runs the debt of <garde> at <racine> on its <constats>, in the mode <mode> (the environment's
+// `GRILLHOUSE_DETTE` by default): writes the file in mode `inscrire` or `elaguer`, then judges.
+// Returns `refus`, the findings to print as refusals, and `lignes`, the lines to print after them
+// (the keys beyond their count, the keys to prune, what the run wrote). An unknown mode, or a file
+// that is not JSON, refuses every finding, behind a refusal that says why. The refusals are the
+// guard's findings in SARIF too, under the results directory <env> names (scripts/resultats.mjs),
+// each with its file, its line when the guard gives one, and its rule.
+export function trancher(racine, garde, constats, mode = process.env[MODE] || undefined, env) {
+  const { refus, lignes } = juge(racine, garde, constats, mode);
+  ecrireSarif({ garde, constats: refus, racine, env: env ?? process.env });
+  return { refus, lignes };
+}
+
+function juge(racine, garde, constats, mode) {
+  let avant;
+  try {
+    if (mode !== undefined && !MODES.has(mode)) {
+      throw new Error(`${MODE}=${mode} : les modes sont « inscrire » et « elaguer ».`);
+    }
+    avant = lire(racine);
+  } catch (e) {
+    return { refus: [{ message: e.message }, ...constats], lignes: [] };
+  }
+  let dette = avant;
+  const lignes = [];
+  if (mode) {
+    dette =
+      mode === 'inscrire' ? inscrire(avant, garde, constats) : elaguer(avant, garde, constats);
+    const f = path.join(racine, FICHIER);
+    if (JSON.stringify(dette) !== JSON.stringify(avant)) {
+      const triee = Object.fromEntries(
+        Object.keys(dette)
+          .sort()
+          .map(g => [g, dette[g]])
+      );
+      writeFileSync(f, `${JSON.stringify(triee, null, 2)}\n`);
+      lignes.push(
+        `📝 ${FICHIER} : la dette de ${garde} est ${mode === 'inscrire' ? 'inscrite' : 'élaguée'}.`
+      );
+    }
+  }
+  const { refus, depasses, corriges, tus } = juger(dette, garde, constats);
+  for (const d of depasses) {
+    lignes.push(
+      `⛔ ${garde} : ${d.fichier} · ${d.regle} — ${d.trouve} constat(s) pour ${d.inscrit} inscrit(s) dans ${FICHIER} : un constat est neuf.`
+    );
+  }
+  for (const c of corriges) {
+    lignes.push(
+      `⚠️  ${garde} : ${c.fichier} · ${c.regle} — ${c.trouve} constat(s) pour ${c.inscrit} inscrit(s) dans ${FICHIER} : npm run grillhouse:dette:elaguer retire ce qui est corrigé.`
+    );
+  }
+  if (tus > 0)
+    lignes.push(`ℹ️  ${garde} : ${tus} constat(s) connu(s), inscrit(s) dans ${FICHIER}.`);
+  return { refus, lignes };
+}