@roomi-fields/grillhouse 0.23.1 → 0.24.0

package/scripts/migrations.mjs

@@ -4,21 +4,37 @@
 //
 // - A migration exports `version` (the version of the package that brings the change of form),
 //   `nom` and `migrer(projet)`, which brings the project at <projet> to the new form and returns
-//   the lines of what it changed: none when the project already has it. It is replayable without
-//   effect: a second pass changes no byte and returns no line.
+//   the lines of what it changed: none when the project already has it. A line `{ aFaire }` is
+//   what it leaves to the project (a copy of the frame the project modified), which the update
+//   writes on its error stream, its exit code non-zero, as `@turbo/codemod` fails on a file it
+//   could not transform. It is replayable without effect: a second pass changes no byte and
+//   returns no line.
 // - MIGRATIONS lists them, each imported by its module; the update plays those newer than the
 //   version the project recorded (`grillhouse.version` of its package.json), in the order of their
 //   versions; a project that recorded none plays them all. The package carries no migration newer
 //   than itself once released, so the range ends with the package.
+// - A migration may also export `restes(projet)`: the lines of what stays to the project once the
+//   update is done, which the update plays after its own update and its regeneration, for each
+//   migration it played, and reports (« reste au projet ») without holding back the version, as a
+//   codemod reports what it leaves without failing (restesAuProjet).
 // - Each migration has its test, tests/unit/migration.<nom>.spec.ts.
 import semver from 'semver';
 import * as charteImportee from './migrations/0.23.0-charte-importee.mjs';
 import * as configVitest from './migrations/0.23.0-config-vitest.mjs';
 import * as crochetsDeSeance from './migrations/0.23.0-crochets-de-seance.mjs';
 import * as marcheDuProjet from './migrations/0.23.0-marche-du-projet.mjs';
+import * as copiesDuCadre from './migrations/0.23.2-copies-du-cadre.mjs';
+import * as circuitSimplifie from './migrations/0.24.0-circuit-simplifie.mjs';
 
 /** The migrations of the package. */
-export const MIGRATIONS = [crochetsDeSeance, configVitest, marcheDuProjet, charteImportee];
+export const MIGRATIONS = [
+  crochetsDeSeance,
+  configVitest,
+  marcheDuProjet,
+  charteImportee,
+  copiesDuCadre,
+  circuitSimplifie,
+];
 
 /**
  * The migrations of <liste> newer than <depuis> (all of them when it is null), in the order of
@@ -32,12 +48,31 @@ export function migrationsAJouer(depuis, liste = MIGRATIONS) {
     .map(({ m }) => m);
 }
 
+/**
+ * What stays to the project at <projet> after the update, for each migration newer than <depuis>
+ * that exports `restes` and names something: `{ version, nom, lignes }`.
+ */
+export function restesAuProjet(projet, depuis, liste = MIGRATIONS) {
+  return migrationsAJouer(depuis, liste)
+    .filter(m => typeof m.restes === 'function')
+    .map(m => ({ version: m.version, nom: m.nom, lignes: m.restes(projet) }))
+    .filter(r => r.lignes.length > 0);
+}
+
 /**
  * Plays on the project at <projet> each migration newer than <depuis>; returns, for each one that
- * changed something, `{ version, nom, lignes }`.
+ * changed something or left something to do, `{ version, nom, lignes, aFaire }`.
  */
 export function migrer(projet, depuis, liste = MIGRATIONS) {
   return migrationsAJouer(depuis, liste)
-    .map(m => ({ version: m.version, nom: m.nom, lignes: m.migrer(projet) }))
-    .filter(r => r.lignes.length > 0);
+    .map(m => {
+      const tout = m.migrer(projet);
+      return {
+        version: m.version,
+        nom: m.nom,
+        lignes: tout.filter(l => typeof l === 'string'),
+        aFaire: tout.filter(l => typeof l !== 'string').map(l => l.aFaire),
+      };
+    })
+    .filter(r => r.lignes.length > 0 || r.aFaire.length > 0);
 }

package/scripts/paquets.d.ts

@@ -0,0 +1,5 @@
+// The types of ./paquets.mjs as the entry `@roomi-fields/grillhouse/paquets` publishes it, for a
+// project's guard that leaves out the packages out of the frame.
+
+/** The names listed in `racine`'s `docs/agents/hors-cadre.txt`: empty without the file. */
+export function horsCadre(racine: string): Set<string>;

package/scripts/paquets.mjs

@@ -12,6 +12,9 @@
 //
 // This module and the ones it imports use Node alone: the update runs them from a source checkout
 // of the frame that installs no dependency.
+//
+// A project's guard imports `horsCadre` by the package's entry `@roomi-fields/grillhouse/paquets`,
+// its types in ./paquets.d.ts (docs/ARCHITECTURE.md, the package's named entries).
 import { existsSync, globSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 

package/scripts/references-par-les-types.mjs

@@ -3,7 +3,8 @@
 // repository's code (a declaration of a package, a member of a type, a function internal to a
 // package), and its references are those the language service resolves to that symbol, never a
 // text that happens to bear its name. scripts/composants-affectes.mjs runs it beside its survey
-// by the names.
+// by the names; scripts/elements-du-lot.mjs reads the declarations and the exports of a lot
+// through the same service (`leService`).
 //
 // - The code read is the files of each component's `tsconfig.json` (its `include`), in one
 //   language service, so that a reference crosses packages. A workspace package's import resolves
@@ -100,14 +101,15 @@ function entreeDe(c, sous = '.') {
   );
 }
 
-const estTest = (c, f) =>
+// Whether the file <f> (absolute) of the component <c> is a test: a test's name, or a test folder.
+export const estTest = (c, f) =>
   NOM_DE_TEST.test(path.basename(f)) ||
   path
     .relative(c.dir, f)
     .split(path.sep)
     .some(d => DOSSIERS_DE_TEST.has(d));
 
-// The language service over the components <tous> of <racine>: { ts, ls, programme, composantDe }
+// The language service over the components <tous> of <racine>: { ls, programme, composantDe }
 // or { raison } when it cannot run.
 function service(ts, racine, tous) {
   const hote = { ...ts.sys, onUnRecoverableConfigFileDiagnostic: () => {} };
@@ -209,6 +211,51 @@ function service(ts, racine, tous) {
   return { ls, programme, composantDe };
 }
 
+// The language service over the components <tous> of <racine>, and what it says of their
+// declarations: `{ ts, ls, programme, checker, composantDe, sources, entree, publie }`, `sources`
+// the production sources it reads (each `{ sf, c }`, the tests and the declaration files left
+// out), `entree(c)` the source of the entry of the component <c> (or null), `publie(c, noeud)`
+// whether that entry exports the symbol whose name is the node <noeud>; or `{ raison }` when it
+// cannot run. scripts/elements-du-lot.mjs reads it.
+export function leService(racine, tous) {
+  const ts = requis('typescript');
+  const s = service(ts, racine, tous);
+  if (s.raison) {
+    return s;
+  }
+  const { programme, composantDe } = s;
+  const checker = programme.getTypeChecker();
+  const sources = programme.getSourceFiles().flatMap(sf => {
+    const c = composantDe(sf.fileName);
+    return !c || estTest(c, sf.fileName) || DECLARATION.test(sf.fileName) ? [] : [{ sf, c }];
+  });
+  const exportes = new Map();
+  const reel = sym => {
+    let x = sym;
+    if (x && x.flags & ts.SymbolFlags.Alias) {
+      x = checker.getAliasedSymbol(x);
+    }
+    return x ? checker.getExportSymbolOfSymbol(x) : x;
+  };
+  const exportsDe = c => {
+    if (!exportes.has(c)) {
+      const f = entreeDe(c);
+      const sf = f ? programme.getSourceFile(f) : undefined;
+      const mod = sf ? checker.getSymbolAtLocation(sf) : undefined;
+      exportes.set(
+        c,
+        mod ? checker.getExportsOfModule(mod).map(x => ({ nom: x.name, sym: reel(x) })) : []
+      );
+    }
+    return exportes.get(c);
+  };
+  const publie = (c, noeud) => {
+    const sym = reel(checker.getSymbolAtLocation(noeud));
+    return Boolean(sym) && exportsDe(c).some(x => x.sym === sym);
+  };
+  return { ts, ...s, checker, sources, entree: c => entreeDe(c), publie };
+}
+
 // The survey by the types of the elements <ecrits> (`elementsEcrits`) in the components <tous> of
 // <racine>, an element that resolves to several declarations kept to those of the files and the
 // components the ticket names (<contexte>: `{ fichiers, composants }`, Sets of file names and of
@@ -224,13 +271,11 @@ export function parLesTypes(racine, tous, ecrits, contexte = {}) {
 }
 
 function releveParLesTypes(racine, tous, ecrits, { fichiers = new Set(), composants = new Set() }) {
-  const ts = requis('typescript');
-  const s = service(ts, racine, tous);
+  const s = leService(racine, tous);
   if (s.raison) {
     return { etat: 'impossible', raison: s.raison, elements: [] };
   }
-  const { ls, programme, composantDe } = s;
-  const checker = programme.getTypeChecker();
+  const { ts, ls, programme, composantDe } = s;
 
   // The declarations of the components' sources, at their top and as members of their types.
   const hauts = [];
@@ -244,11 +289,7 @@ function releveParLesTypes(racine, tous, ecrits, { fichiers = new Set(), composa
       }
     }
   };
-  for (const sf of programme.getSourceFiles()) {
-    const c = composantDe(sf.fileName);
-    if (!c || estTest(c, sf.fileName) || DECLARATION.test(sf.fileName)) {
-      continue;
-    }
+  for (const { sf, c } of s.sources) {
     for (const st of sf.statements) {
       const decls = ts.isVariableStatement(st)
         ? st.declarationList.declarations.filter(d => ts.isIdentifier(d.name))
@@ -270,32 +311,10 @@ function releveParLesTypes(racine, tous, ecrits, { fichiers = new Set(), composa
     }
   }
 
-  // The symbols each component's entry exports.
-  const exportes = new Map();
-  const reel = sym => {
-    let x = sym;
-    if (x && x.flags & ts.SymbolFlags.Alias) {
-      x = checker.getAliasedSymbol(x);
-    }
-    return x ? checker.getExportSymbolOfSymbol(x) : x;
-  };
-  const exportsDe = c => {
-    if (!exportes.has(c)) {
-      const f = entreeDe(c);
-      const sf = f ? programme.getSourceFile(f) : undefined;
-      const mod = sf ? checker.getSymbolAtLocation(sf) : undefined;
-      exportes.set(
-        c,
-        mod ? checker.getExportsOfModule(mod).map(x => ({ nom: x.name, sym: reel(x) })) : []
-      );
-    }
-    return exportes.get(c);
-  };
-  const symDe = d => reel(checker.getSymbolAtLocation(d.noeud));
+  // Whether the entry of its component exports a declaration (a member, when its type is).
   const publie = d => {
     const h = d.haut ?? d;
-    const sym = symDe(h);
-    return Boolean(sym) && exportsDe(h.c).some(x => x.sym === sym);
+    return s.publie(h.c, h.noeud);
   };
 
   // The references of the declaration <d>: [{ c, appel }], its own declarations left out.

package/scripts/registre.mjs

@@ -4,11 +4,11 @@
 // role agent launched in a shell included). An agent resumed by a message has one line per stop; the board
 // reads an agent's latest line, and the transcripts of running ones. The circuit of a ticket
 // (scripts/circuit.mjs) writes a line at the end of each step it leads itself, with no agent
-// (`ligneDEtape`: its role `circuit`, its step and component, one turn, no tokens).
+// (`ligneDEtape`: its role `circuit`, its step, one turn, no tokens).
 //
 // - The line: the project (the main tree of the directory the session opened in, which the hook
-//   reads in CLAUDE_PROJECT_DIR, else in its input's `cwd`), the agent, its ticket (« TON TICKET : »; a sub-agent
-//   whose prompt names none takes that of the regulator that launched it), its role,
+//   reads in CLAUDE_PROJECT_DIR, else in its input's `cwd`), the agent, its ticket (« TON TICKET : »),
+//   its role,
 //   its start and end, its working time and the turns it sums (start and end in milliseconds, the
 //   waits for a message left out), its tokens, its cache reads and its cost when the session wrote
 //   one. All of it is read from the agent's transcript; the agent declares nothing.
@@ -36,14 +36,7 @@ import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from
 import os from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import {
-  lireFichier,
-  ROLE_DU_CIRCUIT,
-  roleDeLAgent,
-  roleDuMeta,
-  ticketDuRegulateur,
-  tourne,
-} from './tableau.mjs';
+import { lireFichier, ROLE_DU_CIRCUIT, roleDeLAgent, roleDuMeta, tourne } from './tableau.mjs';
 import { lacherVerrou, prendreVerrou } from './verrou-de-fichier.mjs';
 
 const REGISTRE =
@@ -87,14 +80,14 @@ export function source(input) {
 // The register's line for this hook input and the reading `t` of its transcript (`lireFichier` or
 // `lireTranscription`), or null. `projet` is the main tree of the session.
 export function ligne(input, t, projet) {
-  const { transcription, role, agent } = source(input);
+  const { role, agent } = source(input);
   if (t.premier === null) {
     return null;
   }
   return {
     projet,
     agent,
-    ticket: t.ticket ?? (transcription ? ticketDuRegulateur(transcription) : null),
+    ticket: t.ticket ?? null,
     role: role ?? t.role,
     debut: new Date(t.premier).toISOString(),
     fin: new Date(t.dernier).toISOString(),
@@ -108,7 +101,7 @@ export function ligne(input, t, projet) {
 
 // The register's line of a step the circuit of <ticket> leads itself (scripts/circuit.mjs), from
 // <debut> to <fin> (ISO dates): one agent per step, its role `circuit`, one turn, no tokens.
-export function ligneDEtape({ projet, ticket, etape, composant, debut, fin }) {
+export function ligneDEtape({ projet, ticket, etape, debut, fin }) {
   const [d, f] = [Date.parse(debut), Date.parse(fin)];
   return {
     projet,
@@ -116,7 +109,6 @@ export function ligneDEtape({ projet, ticket, etape, composant, debut, fin }) {
     ticket,
     role: ROLE_DU_CIRCUIT,
     etape,
-    composant,
     debut,
     fin,
     travail: f - d,