@sylad/cadence 0.2.0

package/dist/deliver.js

@@ -0,0 +1,305 @@
+import { execFileSync, spawnSync } from 'node:child_process';
+import { parse } from 'yaml';
+import { headSha, isAncestor, onRemote, readCommits, repoStatus } from './git.js';
+import { extractRefs, RafError } from './plan.js';
+import { appendDelivery, lastDelivery, lockAlive, lockPath, readLock, releaseLock, removeStaleLock, writeLock } from './state.js';
+const POLL_CI = 15_000;
+const CI_APPEAR = 300_000;
+const POLL_VERIFY = 10_000;
+const CI_OK = new Set(['success', 'skipped', 'neutral']);
+const GH_TIMEOUT = 60_000;
+export const TIMED_OUT = 124;
+const codeText = (code) => (code === TIMED_OUT ? 'délai dépassé' : `code ${code}`);
+export function parseDeliverConfig(text, file) {
+    let raw;
+    try {
+        raw = parse(text);
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const d = raw?.deliver;
+    if (!d || typeof d !== 'object' || Array.isArray(d))
+        throw new RafError(`${file} : clé deliver absente`);
+    const cfg = d;
+    const bad = (what) => new RafError(`${file} : deliver.${what}`);
+    let ci = 'none';
+    if (cfg.ci === 'github' || cfg.ci === 'none')
+        ci = cfg.ci;
+    else if (cfg.ci && typeof cfg.ci === 'object' && typeof cfg.ci.command === 'string') {
+        ci = { command: cfg.ci.command };
+        if (!ci.command.trim())
+            throw bad('ci.command : commande vide');
+    }
+    else if (cfg.ci !== undefined)
+        throw bad('ci : attendu github, none ou { command: "…" }');
+    const seconds = (key, dflt) => {
+        const v = cfg[key];
+        if (v === undefined)
+            return dflt;
+        if (typeof v !== 'number' || !(v > 0))
+            throw bad(`${key} : nombre de secondes positif attendu`);
+        return v;
+    };
+    const deploy = cfg.deploy === undefined ? [] : typeof cfg.deploy === 'string' ? [cfg.deploy] : cfg.deploy;
+    if (!Array.isArray(deploy) || !deploy.every((c) => typeof c === 'string' && c.trim()))
+        throw bad('deploy : liste de commandes non vides attendue');
+    const verify = cfg.verify ?? [];
+    if (!Array.isArray(verify) || verify.length === 0) {
+        throw bad('verify : au moins une vérification (une livraison se prouve par son effet)');
+    }
+    const checks = verify.map((v, i) => {
+        const where = `verify[${i + 1}]`;
+        if (!v || typeof v !== 'object')
+            throw bad(`${where} : { url } ou { command } attendu`);
+        const { url, status, contains, command } = v;
+        if ((url === undefined) === (command === undefined))
+            throw bad(`${where} : exactement un de url ou command`);
+        if (command !== undefined) {
+            if (typeof command !== 'string' || !command.trim())
+                throw bad(`${where}.command : commande non vide attendue`);
+            return { command };
+        }
+        if (typeof url !== 'string')
+            throw bad(`${where}.url : texte attendu`);
+        if (status !== undefined && !Number.isInteger(status))
+            throw bad(`${where}.status : entier attendu`);
+        if (contains !== undefined && typeof contains !== 'string')
+            throw bad(`${where}.contains : texte attendu`);
+        return { url, ...(status === undefined ? {} : { status: status }), ...(contains === undefined ? {} : { contains }) };
+    });
+    return { ci, ciTimeout: seconds('ciTimeout', 1800), deploy: deploy, verify: checks, verifyTimeout: seconds('verifyTimeout', 300), deployTimeout: seconds('deployTimeout', 1800) };
+}
+/** Dépendances réelles : sh, gh, fetch, horloge. */
+export function realDeps(root) {
+    const gh = (args) => {
+        try {
+            return execFileSync('gh', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: GH_TIMEOUT });
+        }
+        catch (e) {
+            const err = e;
+            if (err.code === 'ENOENT')
+                throw new Error('gh introuvable (https://cli.github.com)');
+            if (err.code === 'ETIMEDOUT')
+                throw new Error(`gh sans réponse après ${GH_TIMEOUT / 1000} s`);
+            throw new Error(String(err.stderr || err.message).trim().split('\n').slice(0, 3).join(' '));
+        }
+    };
+    return {
+        exec: (cmd, env, timeoutMs) => {
+            const r = spawnSync('sh', ['-c', cmd], {
+                cwd: root,
+                env: { ...process.env, ...env },
+                stdio: ['ignore', 'inherit', 'inherit'],
+                timeout: Math.max(1_000, timeoutMs),
+                killSignal: 'SIGKILL',
+            });
+            if (r.error?.code === 'ETIMEDOUT' || r.signal)
+                return TIMED_OUT;
+            return r.status ?? 1;
+        },
+        gh: (sha) => JSON.parse(gh(['run', 'list', '--commit', sha, '--json', 'name,status,conclusion'])),
+        ghReady: () => {
+            try {
+                gh(['auth', 'status']);
+                return null;
+            }
+            catch (e) {
+                return e.message;
+            }
+        },
+        fetch: async (url) => {
+            const res = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(20_000) });
+            return { status: res.status, text: await res.text() };
+        },
+        sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+        now: () => Date.now(),
+    };
+}
+function substitute(text, sha) {
+    return text.replaceAll('${SHA}', sha).replaceAll('${SHORT}', sha.slice(0, 7));
+}
+function describeCheck(c, sha) {
+    if (c.command !== undefined)
+        return c.command;
+    return `GET ${substitute(c.url, sha)} → ${c.status ?? 200}${c.contains === undefined ? '' : `, contient « ${substitute(c.contains, sha)} »`}`;
+}
+/** Livre HEAD. 0 livré, 1 étape en échec, 2 refus avant d'agir. */
+export async function deliver(ctx, deps) {
+    const { config, out, err } = ctx;
+    const refuse = (msg) => {
+        err(`deliver : ${msg}`);
+        return 2;
+    };
+    const sha = headSha(ctx.root);
+    if (!sha)
+        return refuse('aucun commit à livrer');
+    const repo = repoStatus(ctx.root);
+    if (repo.dirty)
+        return refuse(`${repo.dirty} fichier(s) suivi(s) modifié(s) : commiter et pousser d'abord`);
+    if (!onRemote(ctx.root, sha))
+        return refuse(`${sha.slice(0, 7)} non poussé : la CI n'a rien construit (git push)`);
+    const lock = readLock(ctx.state);
+    if (lock && lockAlive(lock)) {
+        return refuse(`livraison déjà en cours (${lock.sha.slice(0, 7)}, pid ${lock.pid}, depuis ${lock.started}) — jamais deux à la fois ; ` +
+            `si ce processus n'est plus une livraison : rm ${lockPath(ctx.state)}`);
+    }
+    if (config.ci === 'github' && !ctx.dryRun) {
+        const why = deps.ghReady();
+        if (why)
+            return refuse(`ci: github exige gh authentifié — ${why}`);
+    }
+    const branch = repo.branch ?? 'HEAD détachée';
+    const env = { CADENCE_SHA: sha, CADENCE_SHORT: sha.slice(0, 7), CADENCE_BRANCH: repo.branch ?? '' };
+    if (ctx.dryRun) {
+        out(`Livraison de ${env.CADENCE_SHORT} (${branch}) — simulation, rien n'est exécuté`);
+        out(`  CI : ${typeof config.ci === 'string' ? config.ci : config.ci.command}${config.ci === 'none' ? '' : ` (délai ${config.ciTimeout} s)`}`);
+        out('  Déploiement :');
+        if (config.deploy.length === 0)
+            out('    (aucune commande)');
+        config.deploy.forEach((c, i) => out(`    ${i + 1}. ${c}`));
+        out(`  Vérifications (réessayées pendant ${config.verifyTimeout} s) :`);
+        config.verify.forEach((c, i) => out(`    ${i + 1}. ${describeCheck(c, sha)}`));
+        out(`  Variables : ${Object.entries(env).map(([k, v]) => `${k}=${v}`).join(' ')}`);
+        return 0;
+    }
+    if (lock && removeStaleLock(ctx.state, lock)) {
+        err(`deliver : verrou périmé retiré (pid ${lock.pid} mort, ${lock.sha.slice(0, 7)})`);
+    }
+    if (!writeLock(ctx.state, { pid: process.pid, sha, started: new Date(deps.now()).toISOString() })) {
+        return refuse('une autre livraison vient de démarrer');
+    }
+    try {
+        const fail = (msg) => {
+            err(`deliver : ${msg}`);
+            return 1;
+        };
+        out(`Livraison de ${env.CADENCE_SHORT} (${branch})`);
+        const ci = await waitCi(ctx, deps, sha, env);
+        if (ci)
+            return fail(ci);
+        for (const [i, cmd] of config.deploy.entries()) {
+            out(`→ déploiement ${i + 1}/${config.deploy.length} : ${cmd}`);
+            const code = deps.exec(cmd, env, config.deployTimeout * 1000);
+            if (code !== 0)
+                return fail(`déploiement en échec (${codeText(code)}) : ${cmd}`);
+        }
+        const failed = await verifyAll(ctx, deps, sha, env);
+        if (failed)
+            return fail(failed);
+        const delivered = deliveredLots(ctx, lastDelivery(ctx.state), sha);
+        appendDelivery(ctx.state, ctx.today, sha);
+        out(`✓ livré et vérifié : ${env.CADENCE_SHORT}`);
+        if (delivered)
+            out(delivered);
+        return 0;
+    }
+    finally {
+        releaseLock(ctx.state, process.pid);
+    }
+}
+/** Message d'échec, ou null quand la CI est verte. */
+async function waitCi(ctx, deps, sha, env) {
+    const { ci, ciTimeout } = ctx.config;
+    if (ci === 'none')
+        return null;
+    if (typeof ci === 'object') {
+        ctx.out(`→ CI : ${ci.command}`);
+        const code = deps.exec(ci.command, env, ciTimeout * 1000);
+        return code === 0 ? null : `CI en échec (${codeText(code)}) : ${ci.command}`;
+    }
+    ctx.out(`→ CI : attente des runs GitHub de ${sha.slice(0, 7)}`);
+    const start = deps.now();
+    let last = '';
+    let failingSince = null;
+    for (;;) {
+        let runs = [];
+        let error = null;
+        try {
+            runs = deps.gh(sha);
+            failingSince = null;
+        }
+        catch (e) {
+            // Erreur passagère (réseau, quota d'API) : on réessaie ; persistante, on abandonne avec sa cause.
+            error = e.message;
+            failingSince ??= deps.now();
+        }
+        const elapsed = deps.now() - start;
+        if (error !== null) {
+            if (deps.now() - failingSince >= CI_APPEAR || elapsed >= ciTimeout * 1000)
+                return `gh run list en échec : ${error}`;
+            ctx.err(`  gh run list en échec, nouvel essai : ${error}`);
+        }
+        else if (runs.length === 0) {
+            if (elapsed >= CI_APPEAR)
+                return `aucun run CI pour ce sha après ${CI_APPEAR / 60_000} min (le commit poussé est-il celui que la CI construit ?)`;
+        }
+        else {
+            const pending = runs.filter((r) => r.status !== 'completed');
+            const summary = `${runs.length} run(s), ${runs.length - pending.length} terminé(s)`;
+            if (summary !== last)
+                ctx.out(`  ${summary}`);
+            last = summary;
+            if (pending.length === 0) {
+                const bad = runs.filter((r) => !CI_OK.has(r.conclusion));
+                return bad.length ? `CI en échec : ${bad.map((r) => `${r.name} (${r.conclusion})`).join(', ')}` : null;
+            }
+        }
+        if (elapsed >= ciTimeout * 1000)
+            return `CI non terminée après ${ciTimeout} s`;
+        await deps.sleep(POLL_CI);
+    }
+}
+async function tryCheck(c, deps, sha, env, budgetMs) {
+    if (c.command !== undefined) {
+        const code = deps.exec(c.command, env, budgetMs);
+        return code === 0 ? null : codeText(code);
+    }
+    try {
+        const res = await deps.fetch(substitute(c.url, sha));
+        const want = c.status ?? 200;
+        if (res.status !== want)
+            return `statut ${res.status} (attendu ${want})`;
+        if (c.contains !== undefined && !res.text.includes(substitute(c.contains, sha)))
+            return `« ${substitute(c.contains, sha)} » absent de la réponse`;
+        return null;
+    }
+    catch (e) {
+        return `erreur réseau : ${e.message}`;
+    }
+}
+/** Chaque vérification est réessayée jusqu'au délai commun ; message d'échec ou null. */
+async function verifyAll(ctx, deps, sha, env) {
+    const deadline = deps.now() + ctx.config.verifyTimeout * 1000;
+    for (const [i, c] of ctx.config.verify.entries()) {
+        const label = describeCheck(c, sha);
+        ctx.out(`→ vérification ${i + 1}/${ctx.config.verify.length} : ${label}`);
+        for (;;) {
+            const reason = await tryCheck(c, deps, sha, env, deadline - deps.now());
+            if (reason === null)
+                break;
+            if (deps.now() >= deadline)
+                return `vérification en échec après ${ctx.config.verifyTimeout} s : ${label} — ${reason}`;
+            await deps.sleep(POLL_VERIFY);
+        }
+    }
+    return null;
+}
+/** Ligne des lots cités depuis la livraison précédente, ou null (première livraison, rien de cité). */
+function deliveredLots(ctx, prev, sha) {
+    if (!ctx.plan || !prev || prev === sha)
+        return null;
+    if (!isAncestor(ctx.root, prev, sha)) {
+        return `livraison précédente (${prev.slice(0, 7)}) hors de l'historique de ${sha.slice(0, 7)} (réécrit ?) : lots livrés non calculés`;
+    }
+    const known = new Set(ctx.plan.lots().map((l) => l.id));
+    const ids = new Set();
+    for (const c of readCommits(ctx.root, { range: `${prev}..${sha}` })) {
+        for (const r of extractRefs(`${c.subject}\n${c.body}`, ctx.plan.prefix))
+            if (known.has(r.lot))
+                ids.add(r.lot);
+    }
+    if (ids.size === 0)
+        return null;
+    return `livré : ${[...ids].sort((a, b) => a.localeCompare(b, undefined, { numeric: true })).join(', ')} — raf done si l'effet est celui attendu`;
+}

package/dist/gantt.js

@@ -0,0 +1,176 @@
+export function ganttData(project, bars, today, generated) {
+    return {
+        project,
+        today,
+        generated,
+        bars: bars.map((b) => ({
+            id: b.lot.id,
+            title: b.lot.title,
+            status: b.lot.status,
+            quickwin: b.lot.quickwin,
+            start: b.start,
+            end: b.end,
+            projected: b.projected,
+            commits: b.commits,
+            estimate: b.lot.estimate,
+            after: b.lot.after,
+            tasks: { done: b.lot.tasks.filter((t) => t.status === 'done').length, total: b.lot.tasks.length },
+            notes: b.lot.notes,
+        })),
+    };
+}
+/** A single self-contained HTML file: data, style and script inline, no network access. */
+export function renderGantt(data) {
+    // `</` fermerait la balise script : on l'échappe dans le JSON embarqué.
+    const json = JSON.stringify(data).replace(/</g, '\\u003c');
+    const title = escapeHtml(`${data.project} — reste à faire`);
+    return `<!doctype html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${title}</title>
+<style>${STYLE}</style>
+</head>
+<body>
+<header>
+  <h1>${title}</h1>
+  <p class="meta">Généré le <span id="generated"></span> par raf · aujourd'hui <span id="today"></span></p>
+  <div class="controls">
+    <label><input type="checkbox" id="show-done" checked> terminés</label>
+    <label><input type="checkbox" id="show-dropped"> abandonnés</label>
+    <span class="legend">
+      <i class="sw todo"></i>à faire <i class="sw doing"></i>en cours <i class="sw done"></i>terminé <i class="sw dropped"></i>abandonné <b>⚡</b> quickwin
+    </span>
+  </div>
+</header>
+<main>
+  <div id="chart" role="img" aria-label="Diagramme de Gantt du plan"></div>
+  <div id="tip" hidden></div>
+  <table>
+    <thead><tr><th>Lot</th><th>Titre</th><th>Statut</th><th>Est. (j)</th><th>Début</th><th>Fin</th><th>Commits</th><th>Dernière note</th></tr></thead>
+    <tbody id="rows"></tbody>
+  </table>
+</main>
+<script type="application/json" id="raf-data">${json}</script>
+<script>${SCRIPT}</script>
+</body>
+</html>
+`;
+}
+function escapeHtml(s) {
+    return s.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
+}
+const STYLE = `
+:root { --bg:#fff; --fg:#1b1f24; --muted:#636c76; --grid:#e3e6ea; --todo:#8c959f; --doing:#0969da; --done:#1a7f37; --dropped:#cf222e; --today:#bf8700; }
+@media (prefers-color-scheme: dark) { :root { --bg:#0d1117; --fg:#e6edf3; --muted:#8d96a0; --grid:#262c36; --todo:#6e7781; --doing:#4493f8; --done:#3fb950; --dropped:#f85149; --today:#d29922; } }
+* { box-sizing: border-box; }
+body { margin:0; font:14px/1.45 system-ui, sans-serif; background:var(--bg); color:var(--fg); }
+header, main { padding: 16px 24px; }
+h1 { margin:0 0 4px; font-size:20px; }
+.meta { margin:0 0 8px; color:var(--muted); }
+.controls { display:flex; gap:16px; align-items:center; flex-wrap:wrap; }
+.legend { color:var(--muted); display:flex; gap:6px; align-items:center; }
+.sw { display:inline-block; width:12px; height:12px; border-radius:2px; margin-left:8px; }
+.sw.todo { background:var(--todo); } .sw.doing { background:var(--doing); } .sw.done { background:var(--done); } .sw.dropped { background:var(--dropped); }
+#chart { overflow-x:auto; border:1px solid var(--grid); border-radius:6px; }
+svg text { fill:var(--fg); font-size:12px; }
+svg .axis { fill:var(--muted); }
+svg .grid { stroke:var(--grid); }
+svg .today { stroke:var(--today); stroke-width:2; }
+svg .bar { rx:3; ry:3; }
+svg .bar.todo { fill:var(--todo); } svg .bar.doing { fill:var(--doing); } svg .bar.done { fill:var(--done); } svg .bar.dropped { fill:var(--dropped); }
+svg .bar.projected { fill-opacity:.45; stroke:currentColor; stroke-width:1; }
+svg .bar.projected.todo { color:var(--todo); }
+svg .weekend { fill:var(--grid); opacity:.45; }
+svg .row:hover .bar { stroke:var(--fg); stroke-opacity:.8; }
+#tip { position:fixed; max-width:360px; padding:8px 10px; border-radius:6px; background:var(--fg); color:var(--bg); font-size:12px; pointer-events:none; z-index:2; }
+#tip p { margin:2px 0; }
+table { width:100%; border-collapse:collapse; margin-top:20px; }
+th, td { text-align:left; padding:6px 8px; border-bottom:1px solid var(--grid); vertical-align:top; }
+th { color:var(--muted); font-weight:600; }
+td.date { white-space:nowrap; }
+td.st-doing { color:var(--doing); } td.st-done { color:var(--done); } td.st-dropped { color:var(--dropped); }
+`;
+// Script du navigateur : construit le SVG avec l'API DOM (jamais innerHTML sur les données).
+const SCRIPT = `
+(function () {
+  var data = JSON.parse(document.getElementById('raf-data').textContent);
+  var NS = 'http://www.w3.org/2000/svg';
+  var DAY = 86400000, COL = 18, ROW = 26, LABEL = 280, HEAD = 34;
+  var LABELS = { todo: 'à faire', doing: 'en cours', done: 'terminé', dropped: 'abandonné' };
+  document.getElementById('generated').textContent = data.generated;
+  document.getElementById('today').textContent = data.today;
+  var ms = function (d) { return Date.parse(d + 'T00:00:00Z'); };
+  var el = function (name, attrs, text) {
+    var n = document.createElementNS(NS, name);
+    for (var k in attrs) n.setAttribute(k, attrs[k]);
+    if (text != null) n.textContent = text;
+    return n;
+  };
+  var tip = document.getElementById('tip');
+  function showTip(ev, b) {
+    tip.replaceChildren();
+    var lines = [b.id + ' — ' + b.title, LABELS[b.status] + (b.projected ? ' (prévision)' : '') + ' · ' + b.start + ' → ' + b.end,
+      'estimation ' + b.estimate + ' j · ' + b.commits + ' commit(s)' + (b.tasks.total ? ' · sous-tâches ' + b.tasks.done + '/' + b.tasks.total : '')];
+    if (b.after.length) lines.push('après ' + b.after.join(', '));
+    b.notes.slice(-3).forEach(function (n) { lines.push(n.date + ' : ' + n.text); });
+    lines.forEach(function (t, i) { var p = document.createElement('p'); p.textContent = t; if (i === 0) p.style.fontWeight = '600'; tip.appendChild(p); });
+    tip.hidden = false;
+    tip.style.left = Math.min(ev.clientX + 12, window.innerWidth - 380) + 'px';
+    tip.style.top = (ev.clientY + 14) + 'px';
+  }
+  function render() {
+    var showDone = document.getElementById('show-done').checked;
+    var showDropped = document.getElementById('show-dropped').checked;
+    var bars = data.bars.filter(function (b) { return (showDone || b.status !== 'done') && (showDropped || b.status !== 'dropped'); });
+    var chart = document.getElementById('chart');
+    chart.replaceChildren();
+    if (!bars.length) { chart.textContent = 'Rien à afficher.'; return; }
+    var min = Math.min.apply(null, bars.map(function (b) { return ms(b.start); }).concat([ms(data.today)])) - 2 * DAY;
+    var max = Math.max.apply(null, bars.map(function (b) { return ms(b.end); }).concat([ms(data.today)])) + 3 * DAY;
+    var days = Math.round((max - min) / DAY);
+    var x = function (d) { return LABEL + Math.round((ms(d) - min) / DAY) * COL; };
+    var svg = el('svg', { width: LABEL + days * COL + 48, height: HEAD + bars.length * ROW + 10 });
+    for (var i = 0; i <= days; i++) {
+      var t = new Date(min + i * DAY);
+      if (t.getUTCDay() === 0 || t.getUTCDay() === 6) {
+        svg.appendChild(el('rect', { x: LABEL + i * COL, y: HEAD - 6, width: COL, height: bars.length * ROW + 6, class: 'weekend' }));
+      }
+      if (t.getUTCDay() === 1) {
+        var gx = LABEL + i * COL;
+        svg.appendChild(el('line', { x1: gx, x2: gx, y1: HEAD - 6, y2: HEAD + bars.length * ROW, class: 'grid' }));
+        svg.appendChild(el('text', { x: gx + 3, y: 18, class: 'axis' }, t.toISOString().slice(5, 10)));
+      }
+    }
+    bars.forEach(function (b, r) {
+      var y = HEAD + r * ROW;
+      var g = el('g', { class: 'row', tabindex: 0 });
+      g.appendChild(el('text', { x: 8, y: y + 17 }, (b.quickwin ? '⚡ ' : '') + b.id + '  ' + (b.title.length > 34 ? b.title.slice(0, 33) + '…' : b.title)));
+      var bx = x(b.start), bw = Math.max(COL - 2, x(b.end) + COL - bx - 2);
+      g.appendChild(el('rect', { x: bx, y: y + 5, width: bw, height: ROW - 10, class: 'bar ' + b.status + (b.projected && b.status !== 'doing' ? ' projected' : '') }));
+      g.addEventListener('mousemove', function (ev) { showTip(ev, b); });
+      g.addEventListener('mouseleave', function () { tip.hidden = true; });
+      svg.appendChild(g);
+    });
+    var tx = x(data.today) + COL / 2;
+    svg.appendChild(el('line', { x1: tx, x2: tx, y1: HEAD - 10, y2: HEAD + bars.length * ROW, class: 'today' }));
+    chart.appendChild(svg);
+    var today = x(data.today) - LABEL;
+    chart.scrollLeft = Math.max(0, today - chart.clientWidth / 3);
+
+    var rows = document.getElementById('rows');
+    rows.replaceChildren();
+    bars.forEach(function (b) {
+      var tr = document.createElement('tr');
+      var last = b.notes.length ? b.notes[b.notes.length - 1] : null;
+      [b.id, (b.quickwin ? '⚡ ' : '') + b.title, LABELS[b.status], String(b.estimate), b.start, b.end, String(b.commits), last ? last.date + ' : ' + last.text : '']
+        .forEach(function (v, i) { var td = document.createElement('td'); td.textContent = v; if (i === 2) td.className = 'st-' + b.status; if (i === 4 || i === 5) td.className = 'date'; tr.appendChild(td); });
+      rows.appendChild(tr);
+    });
+  }
+  document.getElementById('show-done').addEventListener('change', render);
+  document.getElementById('show-dropped').addEventListener('change', render);
+  render();
+})();
+`;

package/dist/git.js

@@ -0,0 +1,91 @@
+import { execFileSync } from 'node:child_process';
+import { basename, dirname, resolve } from 'node:path';
+function git(cwd, args) {
+    return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+}
+export function gitRoot(cwd) {
+    try {
+        return git(cwd, ['rev-parse', '--show-toplevel']).trim();
+    }
+    catch {
+        return null;
+    }
+}
+const FIELD = '\x1f';
+const RECORD = '\x1e';
+/** Commits reachable from HEAD, newest first. Empty when the repo has no commit yet. */
+export function readCommits(cwd, opts = {}) {
+    const args = ['log', `--format=%H${FIELD}%cs${FIELD}%s${FIELD}%b${RECORD}`];
+    if (opts.since)
+        args.push(`--since=${opts.since}`);
+    if (opts.range)
+        args.push(opts.range);
+    let out;
+    try {
+        out = git(cwd, args);
+    }
+    catch {
+        return [];
+    }
+    return out
+        .split(RECORD)
+        .map((r) => r.replace(/^\n/, ''))
+        .filter((r) => r.length > 0)
+        .map((r) => {
+        const [sha, day, subject, body = ''] = r.split(FIELD);
+        return { sha, day, subject, body: body.trim() };
+    });
+}
+/**
+ * Dossier où git exécute réellement les hooks : gère worktrees, core.hooksPath
+ * (y compris « ~/… ») et Husky v9, dont `.husky/_` est généré — les hooks à la main vont dans `.husky/`.
+ */
+export function hooksDir(cwd) {
+    const dir = resolve(cwd, git(cwd, ['rev-parse', '--git-path', 'hooks']).trim());
+    return basename(dir) === '_' && basename(dirname(dir)) === '.husky' ? dirname(dir) : dir;
+}
+/** Fichiers modifiés par un commit, relatifs à la racine du dépôt. */
+export function changedFiles(cwd, sha) {
+    return git(cwd, ['diff-tree', '--root', '--no-commit-id', '--name-only', '-r', sha]).split('\n').filter(Boolean);
+}
+function tryGit(cwd, args) {
+    try {
+        return git(cwd, args).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/** Sha complet de HEAD, null tant que le dépôt n'a aucun commit. */
+export function headSha(cwd) {
+    return tryGit(cwd, ['rev-parse', '--verify', '-q', 'HEAD']);
+}
+export function repoStatus(cwd) {
+    const lines = git(cwd, ['status', '--porcelain']).split('\n').filter(Boolean);
+    const untracked = lines.filter((l) => l.startsWith('??')).length;
+    const upstream = tryGit(cwd, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']);
+    const ahead = upstream && headSha(cwd) ? Number(tryGit(cwd, ['rev-list', '--count', '@{u}..HEAD']) ?? 0) : 0;
+    return {
+        branch: tryGit(cwd, ['symbolic-ref', '--short', '-q', 'HEAD']),
+        dirty: lines.length - untracked,
+        untracked,
+        upstream,
+        ahead,
+    };
+}
+/** Le commit est-il contenu dans une branche distante connue localement ? */
+export function onRemote(cwd, sha) {
+    return (tryGit(cwd, ['branch', '-r', '--contains', sha]) ?? '').length > 0;
+}
+/** Chemin d'un fichier propre au dépôt local, dans le dossier git (jamais commité, un par worktree). */
+export function gitPath(cwd, name) {
+    return resolve(cwd, git(cwd, ['rev-parse', '--git-path', name]).trim());
+}
+/** Dossier git commun à tous les worktrees du dépôt. */
+export function gitCommonDir(cwd) {
+    return resolve(cwd, git(cwd, ['rev-parse', '--git-common-dir']).trim());
+}
+/** `a` est-il un ancêtre de `b` (objets présents) ? */
+export function isAncestor(cwd, a, b) {
+    return tryGit(cwd, ['merge-base', '--is-ancestor', a, b]) !== null;
+}

package/dist/hook.js

@@ -0,0 +1,36 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { hooksDir } from './git.js';
+import { RafError } from './plan.js';
+const BEGIN = '# >>> raf (cadence)';
+const END = '# <<< raf (cadence)';
+const BLOCK = `${BEGIN}\ncommand -v raf >/dev/null 2>&1 && raf hook post-commit || true\n${END}\n`;
+/** Adds the raf block to post-commit without touching anything else already there. */
+export function installHook(cwd) {
+    const dir = hooksDir(cwd);
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, 'post-commit');
+    const current = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    if (current.includes(BEGIN))
+        return { path, changed: false };
+    if (current !== '' && !/^#!.*\b(sh|bash|zsh|dash)\b/.test(current)) {
+        throw new RafError(`${path} n'est pas un script shell : y ajouter à la main « raf hook post-commit »`);
+    }
+    let next;
+    if (current === '') {
+        next = `#!/bin/sh\n${BLOCK}`;
+    }
+    else {
+        const lines = current.replace(/\n*$/, '').split('\n');
+        // Un « exit » final empêcherait le bloc de s'exécuter : on l'insère juste avant.
+        const last = lines.length - 1;
+        if (/^\s*exit\b/.test(lines[last]))
+            lines.splice(last, 0, BLOCK.trimEnd());
+        else
+            lines.push(BLOCK.trimEnd());
+        next = `${lines.join('\n')}\n`;
+    }
+    writeFileSync(path, next);
+    chmodSync(path, 0o755);
+    return { path, changed: true };
+}

package/dist/link.js

@@ -0,0 +1,32 @@
+import { extractRefs } from './plan.js';
+export function isMerge(c) {
+    return /^Merge\b/.test(c.subject);
+}
+export function linkCommits(lots, commits, prefix) {
+    const ids = new Set(lots.map((l) => l.id));
+    const tasks = new Set(lots.flatMap((l) => l.tasks.map((t) => `${l.id}/${t.id}`)));
+    const byLot = new Map();
+    const orphans = [];
+    const unknown = [];
+    for (const c of commits) {
+        const refs = extractRefs(`${c.subject}\n${c.body}`, prefix);
+        if (refs.length === 0) {
+            if (!isMerge(c))
+                orphans.push(c);
+            continue;
+        }
+        const seen = new Set();
+        for (const r of refs) {
+            const full = r.task ? `${r.lot}/${r.task}` : r.lot;
+            if (!ids.has(r.lot) || (r.task && !tasks.has(full))) {
+                unknown.push({ commit: c, ref: full });
+                continue;
+            }
+            if (seen.has(r.lot))
+                continue;
+            seen.add(r.lot);
+            byLot.set(r.lot, [...(byLot.get(r.lot) ?? []), c]);
+        }
+    }
+    return { byLot, orphans, unknown };
+}