@roomi-fields/grillhouse 0.0.0-stage → 0.23.1

package/scripts/ligne-etat/ligne-etat.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+// The status line of a Grillhouse project: the person's own status line on the left, the chantier
+// in progress on the right. The project's settings name it as their `statusLine` command.
+//
+//   npx grillhouse ligne-etat    reads Claude Code's status line input on stdin
+//
+// - The left part: the status line command of the person's own settings (~/.claude/settings.json),
+//   run on the same input; without one, `defaut.sh` beside this file.
+// - The right part: `grillhouse-etat.txt` in the project's common git directory, which each
+//   measure of the board writes (`scripts/tableau.mjs`), dim, aligned on the terminal's width
+//   (COLUMNS), on the first line.
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ICI = path.dirname(fileURLToPath(import.meta.url));
+// The columns Claude Code keeps around the status line: two before it, two after.
+const MARGE = 4;
+
+// A colour sequence of the terminal (ESC [ … m).
+const COULEUR = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, 'g');
+
+/** A text without its colour sequences. @param {string} texte */
+export const sansCouleur = texte => texte.replace(COULEUR, '');
+
+/** The cells a text takes on screen. @param {string} texte */
+export const largeurVisible = texte => Array.from(sansCouleur(texte)).length;
+
+/**
+ * The left part with the right one aligned on `colonnes`, on its first line; at least two spaces
+ * between them.
+ * @param {string} gauche
+ * @param {string} droite
+ * @param {number} colonnes
+ * @returns {string}
+ */
+export function composer(gauche, droite, colonnes) {
+  if (!droite) {
+    return gauche;
+  }
+  const [premiere, ...suite] = gauche.split('\n');
+  const vide = Math.max(2, colonnes - largeurVisible(premiere) - largeurVisible(droite) - MARGE);
+  return [`${premiere}${' '.repeat(vide)}\x1b[0;90m${droite}\x1b[0m`, ...suite].join('\n');
+}
+
+/**
+ * The status line command of the person's own settings, or null: none, or this one.
+ * @param {string} home
+ * @returns {string | null}
+ */
+export function commandePersonnelle(home) {
+  try {
+    const s = JSON.parse(readFileSync(path.join(home, '.claude', 'settings.json'), 'utf8'));
+    const c = s.statusLine?.type === 'command' ? s.statusLine.command : null;
+    return c && !c.includes('ligne-etat/ligne-etat.mjs') ? c : null;
+  } catch {
+    return null;
+  }
+}
+
+// What a command prints on `entree`, its output kept when it fails.
+function sortie(commande, entree, cwd) {
+  try {
+    return execFileSync('/bin/sh', ['-c', commande], { input: entree, cwd, encoding: 'utf8' });
+  } catch (e) {
+    return typeof e.stdout === 'string' ? e.stdout : '';
+  }
+}
+
+// The chantier in progress the board last wrote for the project at `projet`, or ''.
+function etat(projet) {
+  try {
+    const commun = execFileSync(
+      'git',
+      ['-C', projet, 'rev-parse', '--path-format=absolute', '--git-common-dir'],
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }
+    ).trim();
+    return readFileSync(path.join(commun, 'grillhouse-etat.txt'), 'utf8').split('\n')[0].trim();
+  } catch {
+    return '';
+  }
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {
+  const entree = readFileSync(0, 'utf8');
+  const projet = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+  const commande = commandePersonnelle(os.homedir()) ?? `bash "${path.join(ICI, 'defaut.sh')}"`;
+  const gauche = sortie(commande, entree, projet).replace(/\n+$/, '');
+  const colonnes = Number(process.env.COLUMNS) || 80;
+  process.stdout.write(`${composer(gauche, etat(projet), colonnes)}\n`);
+}

package/scripts/migrations/0.23.0-charte-importee.mjs

@@ -0,0 +1,47 @@
+// The common charter arrives whole, imported by the project's CLAUDE.md from the package installed
+// (`@node_modules/@roomi-fields/grillhouse/charte.md`), as Claude Code loads a CLAUDE.md and its
+// imports whole; no hook writes it any more, since Claude Code caps a hook's output.
+//
+// - A CLAUDE.md that imports a charter of the frame (`@…grillhouse/charte.md`) other than the
+//   former copy is left: it already has one (Grillhouse imports its source,
+//   `@mods/grillhouse/charte.md`).
+// - The import of the former copy (`@.claude/grillhouse/charte.md`) becomes the import of the
+//   package installed.
+// - The paragraph of the template that gave the charter by the plugin (« Les règles du cadre : la
+//   charte commune, que le greffon du cadre … donne à chaque séance. ») becomes
+//   « Les règles du cadre : @node_modules/@roomi-fields/grillhouse/charte.md ».
+// - A CLAUDE.md that names neither receives that line at its end, after a blank line.
+// - A project without CLAUDE.md is not written.
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+
+export const version = '0.23.0';
+export const nom = 'charte importée';
+
+const IMPORT = '@node_modules/@roomi-fields/grillhouse/charte.md';
+const LIGNE = `Les règles du cadre : ${IMPORT}`;
+const ANCIENNE_COPIE = '@.claude/grillhouse/charte.md';
+// An import of a charter of the frame: `@<chemin>grillhouse/charte.md`, at a word's start.
+const IMPORT_D_UNE_CHARTE = /(?:^|\s)@(\S*grillhouse\/charte\.md)/g;
+// The paragraph of 0.23.0's template that gave the charter by the plugin, up to its blank line.
+const PARAGRAPHE_DU_GREFFON =
+  /^Les règles du cadre : la charte commune, que le greffon[^]*?donne à chaque séance\.$/m;
+
+/** Brings the import of the common charter to the project's CLAUDE.md; returns what it did. */
+export function migrer(projet) {
+  const fichier = path.join(projet, 'CLAUDE.md');
+  if (!existsSync(fichier)) return [];
+  const texte = readFileSync(fichier, 'utf8');
+  const imports = [...texte.matchAll(IMPORT_D_UNE_CHARTE)].map(m => `@${m[1]}`);
+  if (imports.some(i => i !== ANCIENNE_COPIE)) return [];
+  let neuf;
+  if (imports.length > 0) {
+    neuf = texte.replaceAll(ANCIENNE_COPIE, IMPORT);
+  } else if (PARAGRAPHE_DU_GREFFON.test(texte)) {
+    neuf = texte.replace(PARAGRAPHE_DU_GREFFON, LIGNE);
+  } else {
+    neuf = `${texte.replace(/\n*$/, '\n')}\n${LIGNE}\n`;
+  }
+  writeFileSync(fichier, neuf);
+  return [`CLAUDE.md : la charte commune importée du paquet installé (${IMPORT})`];
+}

package/scripts/migrations/0.23.0-config-vitest.mjs

@@ -0,0 +1,105 @@
+// The frame's base configuration of Vitest is the package's: `@roomi-fields/grillhouse/vitest-config`
+// (and `/mesure`), in place of the workspace package `@grillhouse/vitest-config` that the frame's
+// copied files held.
+//
+// - Each source file of the project (`.ts`, `.mts`, `.cts`, `.js`, `.mjs`, `.cjs`; node_modules,
+//   .git, dist, coverage, .turbo, .claude, .beads, .codegraph and .rtfm left out) that names
+//   `@grillhouse/vitest-config` or `@grillhouse/vitest-config/mesure` in quotes names the package's
+//   instead; a root configuration that imports the base by its former path
+//   (`./scripts/vitest-config/base.mjs`, `./packages/grillhouse/scripts/vitest-config/base.mjs`)
+//   imports it by its name.
+// - Each package.json of the project (the root's and each workspace's) that declares
+//   `@grillhouse/vitest-config` declares `@roomi-fields/grillhouse` in the same field in its place,
+//   at the range the root declares (else `^<version>` of the package), unless it already declares
+//   it; the root's workspaces lose the former directory of the package (`scripts/vitest-config`,
+//   `packages/grillhouse/scripts/vitest-config`).
+// - A project already in the new form is not written.
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { VERSION } from '../cadre.mjs';
+import { paquets } from '../paquets.mjs';
+
+export const version = '0.23.0';
+export const nom = 'configuration de base de Vitest';
+
+const ANCIEN = '@grillhouse/vitest-config';
+const PAQUET = '@roomi-fields/grillhouse';
+const NOUVEAU = `${PAQUET}/vitest-config`;
+const ANCIENS_ESPACES = ['scripts/vitest-config', 'packages/grillhouse/scripts/vitest-config'];
+const CHAMPS = ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies'];
+const EXTENSIONS = /\.(?:[mc]?ts|[mc]?js)$/;
+const HORS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'coverage',
+  '.turbo',
+  '.claude',
+  '.beads',
+  '.codegraph',
+  '.rtfm',
+]);
+// A quoted name of the former package, or a former path of the base at the root.
+const NOMME =
+  /(['"])(?:@grillhouse\/vitest-config(\/mesure)?|\.\/(?:packages\/grillhouse\/)?scripts\/vitest-config\/base\.mjs)\1/g;
+
+function sources(racine, rel = '') {
+  return readdirSync(path.join(racine, rel), { withFileTypes: true }).flatMap(e => {
+    const r = rel === '' ? e.name : `${rel}/${e.name}`;
+    if (e.isDirectory()) return HORS.has(e.name) ? [] : sources(racine, r);
+    return e.isFile() && EXTENSIONS.test(e.name) ? [r] : [];
+  });
+}
+
+const lireJson = f => JSON.parse(readFileSync(f, 'utf8'));
+const ecrireJson = (f, v) => writeFileSync(f, `${JSON.stringify(v, null, 2)}\n`);
+
+/** Brings the project to the package's base configuration of Vitest; returns what it did. */
+export function migrer(projet) {
+  const lignes = [];
+  for (const f of sources(projet)) {
+    const texte = readFileSync(path.join(projet, f), 'utf8');
+    const neuf = texte.replace(NOMME, (_, q, mesure) => `${q}${NOUVEAU}${mesure ?? ''}${q}`);
+    if (neuf !== texte) {
+      writeFileSync(path.join(projet, f), neuf);
+      lignes.push(`${f} : importe ${NOUVEAU}`);
+    }
+  }
+  const fracine = path.join(projet, 'package.json');
+  if (!existsSync(fracine)) return lignes;
+  const racine = lireJson(fracine);
+  const plage = CHAMPS.map(c => racine[c]?.[PAQUET]).find(v => v !== undefined) ?? `^${VERSION}`;
+  const declarer = pkg => {
+    let change = false;
+    for (const c of CHAMPS) {
+      if (pkg[c]?.[ANCIEN] === undefined) continue;
+      const { [ANCIEN]: _ancien, ...reste } = pkg[c];
+      const deja = CHAMPS.some(d => pkg[d]?.[PAQUET] !== undefined);
+      pkg[c] = Object.fromEntries(
+        Object.entries(deja ? reste : { ...reste, [PAQUET]: plage }).sort(([a], [b]) =>
+          a.localeCompare(b, 'en')
+        )
+      );
+      change = true;
+    }
+    return change;
+  };
+  for (const { dossier, pkg } of paquets(projet)) {
+    if (ANCIENS_ESPACES.includes(dossier) || !declarer(pkg)) continue;
+    ecrireJson(path.join(projet, dossier, 'package.json'), pkg);
+    lignes.push(`${dossier}/package.json : déclare ${PAQUET} à la place de ${ANCIEN}`);
+  }
+  const declare = declarer(racine);
+  if (declare) lignes.push(`package.json : déclare ${PAQUET} à la place de ${ANCIEN}`);
+  const liste = Array.isArray(racine.workspaces) ? racine.workspaces : racine.workspaces?.packages;
+  const restants = Array.isArray(liste) ? liste.filter(e => !ANCIENS_ESPACES.includes(e)) : liste;
+  const espaces = Array.isArray(liste) && restants.length !== liste.length;
+  if (espaces) {
+    racine.workspaces = Array.isArray(racine.workspaces)
+      ? restants
+      : { ...racine.workspaces, packages: restants };
+    lignes.push(`package.json : l'ancien dossier de ${ANCIEN} quitte les workspaces`);
+  }
+  if (declare || espaces) ecrireJson(fracine, racine);
+  return lignes;
+}

package/scripts/migrations/0.23.0-crochets-de-seance.mjs

@@ -0,0 +1,55 @@
+// The hooks of Claude Code come from the frame's plugin (mods/grillhouse/hooks/hooks.json): the
+// project's settings no longer run the frame's session scripts by their path.
+//
+// - In the project's `.claude/settings.json`, each hook whose command runs one of the frame's former
+//   session scripts under `$CLAUDE_PROJECT_DIR/scripts/` (session-start.sh, structure-guard.sh,
+//   verrous/ticket-du-sous-agent.mjs, registre.mjs) goes; a group left without a hook goes, an
+//   event left without a group goes, and `hooks` left empty goes. A hook of the project's own stays,
+//   and so do the other keys, in their order.
+// - A project without settings, or whose settings hold none of these hooks, is not written.
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+
+export const version = '0.23.0';
+export const nom = 'crochets de séance';
+
+// The frame's former session scripts, as the project's settings ran them.
+const ANCIENS = [
+  'scripts/session-start.sh',
+  'scripts/structure-guard.sh',
+  'scripts/verrous/ticket-du-sous-agent.mjs',
+  'scripts/registre.mjs',
+];
+const duCadre = crochet =>
+  typeof crochet?.command === 'string' &&
+  ANCIENS.some(s => crochet.command.includes(`$CLAUDE_PROJECT_DIR/${s}`));
+
+/** Removes the frame's former session hooks from the project's settings; returns what it did. */
+export function migrer(projet) {
+  const f = path.join(projet, '.claude', 'settings.json');
+  if (!existsSync(f)) return [];
+  const reglages = JSON.parse(readFileSync(f, 'utf8'));
+  if (reglages.hooks === null || typeof reglages.hooks !== 'object') return [];
+  const retires = [];
+  const hooks = {};
+  for (const [evenement, groupes] of Object.entries(reglages.hooks)) {
+    if (!Array.isArray(groupes)) {
+      hooks[evenement] = groupes;
+      continue;
+    }
+    const restants = groupes
+      .map(g => {
+        if (!Array.isArray(g?.hooks)) return g;
+        const gardes = g.hooks.filter(c => !duCadre(c));
+        for (const c of g.hooks) if (duCadre(c)) retires.push(`${evenement} : ${c.command}`);
+        return gardes.length > 0 ? { ...g, hooks: gardes } : null;
+      })
+      .filter(g => g !== null);
+    if (restants.length > 0) hooks[evenement] = restants;
+  }
+  if (retires.length === 0) return [];
+  if (Object.keys(hooks).length > 0) reglages.hooks = hooks;
+  else delete reglages.hooks;
+  writeFileSync(f, `${JSON.stringify(reglages, null, 2)}\n`);
+  return retires.map(r => `.claude/settings.json : crochet retiré, que le greffon porte (${r})`);
+}

package/scripts/migrations/0.23.0-marche-du-projet.mjs

@@ -0,0 +1,82 @@
+// The frame's plugin comes from the marketplace roomi-fields, which names the package npm, and
+// nothing of a project is published: the marketplace of the project's own, which an earlier update
+// wrote, goes (`grillhouse maj` then declares roomi-fields and enables `grillhouse@roomi-fields`).
+//
+// - The project's `.claude-plugin/marketplace.json` goes when it is the frame's: its name begins
+//   with `grillhouse-` and each plugin it lists is `grillhouse`, from the project's package
+//   (`./node_modules/@roomi-fields/grillhouse/…`); `.claude-plugin/` left empty goes.
+// - In `.claude/settings.json` and `.claude/settings.local.json` (where the add of a marketplace of
+//   a directory wrote it), each marketplace whose name begins with `grillhouse-` and that is the
+//   project's root (a directory, `./` or `.`) leaves `extraKnownMarketplaces`, and its plugin,
+//   `grillhouse@<name>`, leaves `enabledPlugins`. A key left empty goes; the other keys stay, in
+//   their order.
+// - A project without them is not written.
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+
+export const version = '0.23.0';
+export const nom = 'place de marché du projet';
+
+const PREFIXE = 'grillhouse-';
+const SOURCE_DU_PAQUET = './node_modules/@roomi-fields/grillhouse';
+const REGLAGES = ['.claude/settings.json', '.claude/settings.local.json'];
+
+const lireJson = f => {
+  try {
+    return JSON.parse(readFileSync(f, 'utf8'));
+  } catch {
+    return null;
+  }
+};
+
+// Whether the manifest <m> is the frame's marketplace of a project.
+const duCadre = m =>
+  typeof m?.name === 'string' &&
+  m.name.startsWith(PREFIXE) &&
+  Array.isArray(m.plugins) &&
+  m.plugins.length > 0 &&
+  m.plugins.every(
+    p =>
+      p?.name === 'grillhouse' &&
+      typeof p.source === 'string' &&
+      p.source.startsWith(`${SOURCE_DU_PAQUET}/`)
+  );
+
+// Whether the entry <e> of `extraKnownMarketplaces`, named <n>, is the project's own marketplace.
+const declareDuCadre = (n, e) =>
+  n.startsWith(PREFIXE) && e?.source?.source === 'directory' && ['./', '.'].includes(e.source.path);
+
+// Takes the project's marketplace off the settings file <rel> of the project at <projet>.
+function retirerDesReglages(projet, rel) {
+  const f = path.join(projet, rel);
+  if (!existsSync(f)) return [];
+  const reglages = JSON.parse(readFileSync(f, 'utf8'));
+  const marches = reglages.extraKnownMarketplaces;
+  if (!marches || typeof marches !== 'object') return [];
+  const noms = Object.keys(marches).filter(n => declareDuCadre(n, marches[n]));
+  if (noms.length === 0) return [];
+  for (const n of noms) {
+    delete marches[n];
+    delete reglages.enabledPlugins?.[`grillhouse@${n}`];
+  }
+  if (Object.keys(marches).length === 0) delete reglages.extraKnownMarketplaces;
+  if (reglages.enabledPlugins && Object.keys(reglages.enabledPlugins).length === 0) {
+    delete reglages.enabledPlugins;
+  }
+  writeFileSync(f, `${JSON.stringify(reglages, null, 2)}\n`);
+  return noms.map(n => `${rel} : place de marché du projet retirée (${n}, grillhouse@${n})`);
+}
+
+/** Takes the marketplace of the project's own off the project; returns what it did. */
+export function migrer(projet) {
+  const lignes = [];
+  const dossier = path.join(projet, '.claude-plugin');
+  const manifeste = path.join(dossier, 'marketplace.json');
+  if (existsSync(manifeste) && duCadre(lireJson(manifeste))) {
+    rmSync(manifeste);
+    if (readdirSync(dossier).length === 0) rmSync(dossier, { recursive: true });
+    lignes.push('.claude-plugin/marketplace.json : place de marché du projet retirée');
+  }
+  for (const rel of REGLAGES) lignes.push(...retirerDesReglages(projet, rel));
+  return lignes;
+}

package/scripts/migrations.mjs

@@ -0,0 +1,43 @@
+// The migrations of a project from one version of the frame to the next, as the transforms of
+// `npx @turbo/codemod migrate`: one module per change of form, written once, in
+// scripts/migrations/<version>-<nom>.mjs, which `grillhouse maj` plays (scripts/grillhouse-maj.mjs).
+//
+// - 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.
+// - 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.
+// - 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';
+
+/** The migrations of the package. */
+export const MIGRATIONS = [crochetsDeSeance, configVitest, marcheDuProjet, charteImportee];
+
+/**
+ * The migrations of <liste> newer than <depuis> (all of them when it is null), in the order of
+ * their versions; two of one version keep their order in the list.
+ */
+export function migrationsAJouer(depuis, liste = MIGRATIONS) {
+  return liste
+    .map((m, rang) => ({ m, rang }))
+    .filter(({ m }) => depuis === null || semver.gt(m.version, depuis))
+    .sort((a, b) => semver.compare(a.m.version, b.m.version) || a.rang - b.rang)
+    .map(({ m }) => m);
+}
+
+/**
+ * Plays on the project at <projet> each migration newer than <depuis>; returns, for each one that
+ * changed something, `{ version, nom, lignes }`.
+ */
+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);
+}