@sylad/cadence 0.14.0 → 0.16.0

package/dist/repos.js

@@ -0,0 +1,72 @@
+import { existsSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { lotWork } from './audit.js';
+import { gitRoot } from './git.js';
+/**
+ * Résout les dépôts voisins d'un lot depuis le dossier du projet (la racine de son dépôt). Chaque chemin doit exister et
+ * être dans un dépôt git ; un doublon, ou le dépôt du projet lui-même, n'est compté qu'une fois (le second est ignoré sans bruit).
+ * Les chemins qui ne vont pas sont rendus en `problems`, à refuser avant d'agir.
+ */
+export function resolveLotRepos(base, lot) {
+    const repos = [];
+    const failures = [];
+    const own = gitRoot(base) ?? resolve(base);
+    for (const { path: rel, cite } of lot.repos ?? []) {
+        const dir = resolve(base, rel);
+        if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+            failures.push({ rel, why: `dossier introuvable (${dir})` });
+            continue;
+        }
+        const root = gitRoot(dir);
+        if (!root) {
+            failures.push({ rel, why: `${dir} n'est pas dans un dépôt git` });
+            continue;
+        }
+        if (root === own || repos.some((r) => r.path === root))
+            continue;
+        repos.push({ rel, path: root, ...(cite ? { cite } : {}) });
+    }
+    return { repos, failures, problems: failures.map((f) => `dépôt voisin ${f.rel} : ${f.why}`) };
+}
+/**
+ * Commits à relire du lot dans un dépôt voisin, du plus récent au plus ancien : ceux qui citent le lot, selon les références
+ * du plan, et tombent dans la période du lot (de son démarrage à sa fin). Rien n'est déduit du dépôt ni du nom du projet. Pour un
+ * voisin partagé entre projets, le lot déclare `cite` : le commit doit en plus contenir cette chaîne (sous-chaîne, sans tenir
+ * compte de la casse, dans le sujet et le corps). Sans `cite`, les commits d'une autre application qui citent le même id comptent.
+ */
+export function repoWork(plan, repo, lotId) {
+    const lot = plan.lots().find((l) => l.id === lotId);
+    const inPeriod = lotWork(plan, repo.path, lotId).filter((c) => (!lot?.started || c.day >= lot.started) && (!lot?.finished || c.day <= lot.finished));
+    if (!repo.cite)
+        return inPeriod;
+    const needle = repo.cite.toLowerCase();
+    return inPeriod.filter((c) => `${c.subject}\n${c.body}`.toLowerCase().includes(needle));
+}
+/** Sha du dernier commit du lot de chaque dépôt voisin (null : aucun), sous le chemin déclaré — ce qu'un verdict de revue enregistre. */
+export function repoShas(plan, repos, lotId) {
+    return Object.fromEntries(repos.map((r) => [r.rel, repoWork(plan, r, lotId)[0]?.sha ?? null]));
+}
+const short = (c) => `${c.sha.slice(0, 7)} ${c.subject}`;
+/**
+ * Lignes des commits du lot dans ses dépôts voisins, pour `raf commits` et `raf show` : une section par dépôt, du plus
+ * ancien au plus récent comme la liste du projet. Un dépôt introuvable est dit, il ne fait pas échouer la lecture.
+ */
+export function repoSections(plan, base, lot, indent = '') {
+    const { repos, failures } = resolveLotRepos(base, lot);
+    const lines = [];
+    for (const { path: rel } of lot.repos ?? []) {
+        const found = repos.find((r) => r.rel === rel);
+        if (!found) {
+            const failed = failures.find((f) => f.rel === rel);
+            if (failed)
+                lines.push(`${indent}dépôt ${rel} : introuvable (${failed.why})`);
+            continue;
+        }
+        const commits = repoWork(plan, found, lot.id).reverse();
+        if (commits.length === 0)
+            lines.push(`${indent}dépôt ${rel} : aucun commit du lot`);
+        else
+            lines.push(`${indent}dépôt ${rel} :`, ...commits.map((c) => `${indent}  ${short(c)}`));
+    }
+    return lines;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylad/cadence",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "A small, repo-native working method: a versioned plan linked to your commits, a changelog with screenshots, session rituals and deliveries proven by their effect.",
   "license": "MIT",
   "author": "Sylvain Ladoire",

package/skills/session-close/SKILL.md

@@ -8,12 +8,13 @@ description: Close a work session on a repository that uses cadence — plan hyg
 ## Where to run
 
 Every `cadence` / `raf` command works on the git repository of the current directory. When the
-session runs from a parent folder that holds several projects (not itself a repository), run each
-command inside the project concerned: `cd <project> && cadence …`. The projects are the sub-folders
-that contain `docs/plan/raf.yaml`, or a `cadence.yaml` with a `plan:` key.
+session runs from a parent folder that holds several projects (not itself a repository), run
+`cadence session close --all` there (`--depth 2` for projects one folder deeper): one "## project"
+section per sub-folder that contains `docs/plan/raf.yaml`, or a `cadence.yaml` with a `plan:` key.
+Other commands (`raf …`, `cadence deliver`) still run inside the project concerned: `cd <project> && cadence …`.
 
-With no project named, run `cadence session close` in each project touched during the session
-(`git log --since` or `git status` tell which) and close each one.
+With no project named, run `cadence session close --all` from the parent folder, or `cadence session close` in each project touched during the session
+(`git log --since` or `git status` tell which), and close each one.
 
 ## Steps
 

package/skills/session-start/SKILL.md

@@ -12,11 +12,12 @@ proposes, and stops.
 ## Where to run
 
 Every `cadence` / `raf` command works on the git repository of the current directory. When the
-session runs from a parent folder that holds several projects (not itself a repository), run each
-command inside the project concerned: `cd <project> && cadence …`. The projects are the sub-folders
-that contain `docs/plan/raf.yaml`, or a `cadence.yaml` with a `plan:` key.
+session runs from a parent folder that holds several projects (not itself a repository), run
+`cadence session start --all` there (`--depth 2` for projects one folder deeper): one "## project"
+section per sub-folder that contains `docs/plan/raf.yaml`, or a `cadence.yaml` with a `plan:` key.
+Other commands (`raf …`, `cadence deliver`) still run inside the project concerned: `cd <project> && cadence …`.
 
-With no project named, run `cadence session start` in **each** project that has a plan and report
+With no project named, run `cadence session start --all` from the parent folder (or `cadence session start` in **each** project that has a plan) and report
 one or two lines per project (in progress, drift, notes left at the last close), then propose the
 three most useful items across projects and wait. With a project named, work in that one only.
 

package/templates/orchestrate/fix-minors.md

@@ -1,5 +1,6 @@
 Work in `{{chemin}}` on lot `{{lot}}` — "{{titre}}" — of its plan.
 A fresh review found only minor findings: the lot is compliant, and this is the one pass that treats them.
+{{repos}}
 Commits of the lot so far:
 {{commits}}
 

package/templates/orchestrate/fix.md

@@ -1,5 +1,6 @@
 Work in `{{chemin}}` on lot `{{lot}}` — "{{titre}}" — of its plan. A fresh review of the commits
 of this lot found the defects below; fix them, and nothing else.
+{{repos}}
 Commits of the lot so far:
 {{commits}}
 

package/templates/orchestrate/implement.md

@@ -1,6 +1,7 @@
 Work in `{{chemin}}` on lot `{{lot}}` — "{{titre}}" — of its plan
 (`docs/plan/raf.yaml`, or the file named by `plan:` in `cadence.yaml`; read the lot, its notes and sub-tasks, and the project's CLAUDE.md first).
 Goal: {{objectif}}
+{{repos}}
 Rules: test first; commit each sub-part as soon as its tests pass, with explicit paths (never
 `git add -A` or `commit -a`), and a message that cites the lot (`feat({{lot}}): …`); run the project's
 full test suite and build before reporting; do not push, deliver, run `raf done`, `raf ux` or

package/templates/orchestrate/precheck.md

@@ -1,6 +1,7 @@
 Pre-check for lot `{{lot}}` — "{{titre}}" — of the repository `{{chemin}}`, as the read-only pre-check reader.
 Question: is the deliverable of this lot ALREADY in the repository (done by another lot, or by a correction)?
 Goal of the lot: {{objectif}}
+{{repos}}
 Read the lot, its notes and sub-tasks in the plan (`docs/plan/raf.yaml`, or the file named by `plan:` in `cadence.yaml`),
 then look for the deliverable in the code and tests (`git log`, `grep`, reading the files the lot names). Do not
 implement anything and do not run the full test suite: this is a quick look.

package/templates/orchestrate/review-recheck.md

@@ -4,6 +4,7 @@ treated them. Check that the minor findings fixed are fixed, that the fixes brok
 rest of the lot is still sound: read the diff yourself from the commits that cite the lot
 (`raf commits {{lot}}`, or `git log`), run the checks, report real defects only. A new minor finding
 is reported, not a reason to ask for another pass. This is a code review only.
+{{repos}}
 {{checks}}
 {{choix}}
 A proposed sub-task describes an observable bug (a wrong output, a crash, a measured regression); any other minor finding stays a note of this lot, not a sub-task.

package/templates/orchestrate/review-small.md

@@ -2,6 +2,7 @@ Review lot `{{lot}}` — "{{titre}}" — of the repository `{{chemin}}`, followi
 This lot is small: one single pass covers the code review AND the usability review.
 You are given the repository path and the lot id only: read the diff yourself from the commits that
 cite the lot (`raf commits {{lot}}`, or `git log`), run the checks, report real defects only.
+{{repos}}
 {{ux}}
 {{checks}}
 {{choix}}

package/templates/orchestrate/review.md

@@ -1,6 +1,7 @@
 Review lot `{{lot}}` — "{{titre}}" — of the repository `{{chemin}}`, following your agent instructions.
 You are given the repository path and the lot id only: read the diff yourself from the commits that
 cite the lot (`raf commits {{lot}}`, or `git log`), run the checks, report real defects only.
+{{repos}}
 {{checks}}
 {{choix}}
 A proposed sub-task describes an observable bug (a wrong output, a crash, a measured regression); any other minor finding stays a note of this lot, not a sub-task.