@sylad/cadence 1.40.0 → 1.42.1

package/dist/plan-read.js

@@ -0,0 +1,146 @@
+import { isDay } from './dates.js';
+import { RESOURCE_NAME, RESOURCES_BAD_LIST, SCREENS, STATUSES } from './plan.js';
+import { readParent } from './plan-ids.js';
+const GATE_INVALID = 'gate invalide : count: entier ≥ 1 et un critère spec: true ou screen: page attendus';
+/** Lit `gate: { count: N, spec: true }` ou `{ count: N, screen: page }` ; toute autre forme est un problème du lot et une condition jamais remplie. */
+function readGate(raw, problems) {
+    if (raw == null)
+        return undefined;
+    const invalid = () => {
+        problems.push(GATE_INVALID);
+        return { invalid: true };
+    };
+    if (typeof raw !== 'object' || Array.isArray(raw))
+        return invalid();
+    const g = raw;
+    if (!Number.isInteger(g.count) || g.count < 1)
+        return invalid();
+    const criteria = [...(g.spec === true ? ['spec'] : []), ...(g.screen === 'page' ? ['screen'] : [])];
+    const others = Object.keys(g).filter((k) => k !== 'count' && k !== 'spec' && k !== 'screen');
+    if (criteria.length !== 1 || others.length || ('spec' in g && g.spec !== true) || ('screen' in g && g.screen !== 'page'))
+        return invalid();
+    return { count: g.count, criterion: criteria[0] };
+}
+/** `state:` et `state_before:` écrits à la main avec un non-texte : signalés, la clé étant écartée. */
+function checkStateNames(raw, problems) {
+    for (const k of ['state', 'state_before'])
+        if (raw[k] != null && typeof raw[k] !== 'string')
+            problems.push(`${k} : un nom d'état attendu (reçu « ${String(raw[k])} »)`);
+}
+export function normalizeLot(raw, problems = []) {
+    const status = STATUSES.includes(raw.status) ? raw.status : 'todo';
+    const asDay = (field) => {
+        const v = raw[field];
+        if (v == null)
+            return undefined;
+        if (isDay(v))
+            return v;
+        problems.push(`${field} « ${String(v)} » n'est pas une date AAAA-MM-JJ`);
+        return undefined;
+    };
+    const after = raw.after == null ? [] : Array.isArray(raw.after) ? raw.after.map(String) : [String(raw.after)];
+    const last = asDay('last');
+    let uses;
+    if (raw.uses != null) {
+        if (Array.isArray(raw.uses) && raw.uses.every((n) => typeof n === 'string' && RESOURCE_NAME.test(n)))
+            uses = [...new Set(raw.uses)];
+        else
+            problems.push(`uses ${RESOURCES_BAD_LIST}`);
+    }
+    let screen;
+    if (raw.screen != null) {
+        if (SCREENS.includes(raw.screen))
+            screen = raw.screen;
+        else
+            problems.push(`screen « ${String(raw.screen)} » inconnu (${SCREENS.join(', ')})`);
+        if (screen && raw.visible !== true)
+            problems.push(`screen « ${screen} » sans visible : un écran est un changement visible`);
+    }
+    let spec;
+    if (raw.spec != null) {
+        if (raw.spec === true)
+            spec = true;
+        else if (raw.spec !== false)
+            problems.push(`spec : true ou false attendu (reçu « ${String(raw.spec)} »)`);
+    }
+    checkStateNames(raw, problems);
+    const gate = readGate(raw.gate, problems);
+    const okRaw = raw.docs_ok;
+    const docsOk = okRaw && typeof okRaw === 'object' && typeof okRaw.reason === 'string' && okRaw.reason.trim() !== '' ? { date: String(okRaw.date ?? ''), reason: okRaw.reason.trim() } : undefined;
+    return {
+        id: String(raw.id),
+        ...readParent(raw.parent, problems),
+        title: String(raw.title ?? ''),
+        status,
+        ...(typeof raw.state === 'string' && raw.state.trim() !== '' ? { state: raw.state.trim() } : {}),
+        ...(typeof raw.state_before === 'string' && raw.state_before.trim() !== '' ? { stateBefore: raw.state_before.trim() } : {}),
+        estimate: typeof raw.estimate === 'number' && raw.estimate > 0 ? raw.estimate : 1,
+        quickwin: raw.quickwin === true,
+        visible: raw.visible === true,
+        ...(screen ? { screen } : {}),
+        ...(spec ? { spec } : {}), ...(raw.local === true ? { local: true } : {}),
+        ...(gate ? { gate } : {}),
+        ...(typeof raw.public === 'string' && raw.public.trim() !== '' ? { public: raw.public.trim() } : {}),
+        ...(typeof raw.goal === 'string' && raw.goal.trim() !== '' ? { goal: raw.goal.trim() } : {}),
+        ...(Number.isInteger(raw.every) && raw.every > 0 ? { every: raw.every } : {}),
+        ...(last ? { last } : {}),
+        after,
+        ...(uses?.length ? { uses } : {}),
+        created: asDay('created'),
+        started: asDay('started'),
+        finished: asDay('finished'),
+        notes: Array.isArray(raw.notes)
+            ? raw.notes.map((n) => ({ date: String(n.date ?? ''), text: String(n.text ?? '') }))
+            : [],
+        tasks: Array.isArray(raw.tasks)
+            ? raw.tasks.map((t) => ({
+                id: String(t.id),
+                title: String(t.title ?? ''),
+                status: STATUSES.includes(t.status) ? t.status : 'todo',
+            }))
+            : [],
+        ...(repoList(raw.repos).length ? { repos: repoList(raw.repos) } : {}),
+        ...(asVerdict(raw.ux) ? { ux: asVerdict(raw.ux) } : {}),
+        ...(asVerdict(raw.review) ? { review: asVerdict(raw.review) } : {}),
+        ...(docsOk ? { docsOk } : {}),
+        problems,
+    };
+}
+/**
+ * Dépôts voisins déclarés : une chaîne (le chemin) ou un objet `{ path, cite }`, seuls ou en liste (une valeur seule vaut une
+ * liste d'un dépôt). Une entrée sans chemin textuel est écartée ; un `cite` vide ou non textuel vaut pas de `cite`.
+ */
+function repoList(raw) {
+    const items = Array.isArray(raw) ? raw : raw == null ? [] : [raw];
+    const out = [];
+    for (const item of items) {
+        const path = typeof item === 'string' ? item : item && typeof item === 'object' && typeof item.path === 'string' ? item.path : '';
+        if (path.trim() === '')
+            continue;
+        const cite = item && typeof item === 'object' ? item.cite : undefined;
+        out.push({ path: path.trim(), ...(typeof cite === 'string' && cite.trim() !== '' ? { cite: cite.trim() } : {}) });
+    }
+    return out;
+}
+function asVerdict(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const v = raw;
+    // Écrit à la main sans verdict (clé absente, vide ou blanche) : rien n'a été dit de la revue, la porte
+    // reste fermée — comme `raf ux` et `raf review` refusent d'enregistrer un verdict vide.
+    if (String(v.verdict ?? '').trim() === '')
+        return undefined;
+    const verdict = { date: String(v.date ?? ''), verdict: String(v.verdict) };
+    // Champ présent mais vide : relu « jusqu'à rien », comme un verdict noté sans commit.
+    if ('commit' in v)
+        verdict.commit = v.commit == null || String(v.commit).trim() === '' ? null : String(v.commit).trim();
+    if (v.repos && typeof v.repos === 'object' && !Array.isArray(v.repos)) {
+        const repos = Object.entries(v.repos).map(([k, sha]) => [k, sha == null || String(sha).trim() === '' ? null : String(sha).trim()]);
+        if (repos.length)
+            verdict.repos = Object.fromEntries(repos);
+    }
+    const r = v.reporte;
+    if (r && typeof r === 'object' && !Array.isArray(r) && r.de != null && r.vers != null)
+        verdict.reporte = { de: String(r.de), vers: String(r.vers), patchId: String(r.patchId ?? '') };
+    return verdict;
+}

package/dist/plan-states.js

@@ -0,0 +1,119 @@
+import { isObject, list } from './yaml-keys.js';
+import { STATUSES } from './plan.js';
+function parseBases(raw, bad) {
+    if (!isObject(raw))
+        throw bad('states doit être un objet { état: statut de base }');
+    const states = {};
+    for (const [name, base] of Object.entries(raw)) {
+        if (!STATUSES.includes(base))
+            throw bad(`states.${name} : statut de base « ${String(base)} » inconnu (attendu : ${STATUSES.join(', ')})`);
+        states[name] = base;
+    }
+    const bases = Object.values(states);
+    if (!['todo', 'doing', 'done'].every((b) => bases.includes(b)))
+        throw bad('states doit déclarer au moins un état todo, un doing et un done');
+    return states;
+}
+function parseTransitions(raw, states, bad) {
+    if (!isObject(raw))
+        throw bad('transitions doit être un objet { état: [états permis] }');
+    const transitions = {};
+    for (const [from, tos] of Object.entries(raw)) {
+        if (!Object.hasOwn(states, from))
+            throw bad(`transitions : « ${from} » n'est pas un état déclaré`);
+        for (const to of list(tos))
+            if (!Object.hasOwn(states, to))
+                throw bad(`transitions.${from} : « ${to} » n'est pas un état déclaré`);
+        transitions[from] = list(tos);
+    }
+    return transitions;
+}
+function requireNames(p, bad) {
+    for (const k of ['doneState', 'blockedState'])
+        if (p[k] != null && typeof p[k] !== 'string')
+            throw bad(`${k} : un nom d'état attendu`);
+}
+/**
+ * Lit `plan.states`, `plan.transitions`, `plan.doneState` et `plan.blockedState` de cadence.yaml : `{ states }` ou `{}` quand rien n'est déclaré.
+ * `foreign` : le plan est tenu par un autre outil (lots, fields, statuses, estimates), dont les états sont les siens.
+ */
+export function parseStates(p, bad, foreign) {
+    if (p.states == null) {
+        for (const k of ['transitions', 'doneState', 'blockedState'])
+            if (p[k] != null)
+                throw bad(`${k} demande plan.states`);
+        return {};
+    }
+    if (foreign)
+        throw bad('states ne va pas avec un plan tenu par un autre outil (lots, fields, statuses, estimates) : ses états sont les siens');
+    const states = parseBases(p.states, bad);
+    const model = { states };
+    if (p.transitions != null)
+        model.transitions = parseTransitions(p.transitions, states, bad);
+    requireNames(p, bad);
+    if (p.doneState != null) {
+        if (states[String(p.doneState)] !== 'done')
+            throw bad(`doneState : « ${String(p.doneState)} » n'est pas un état done`);
+        model.done = String(p.doneState);
+    }
+    if (p.blockedState != null) {
+        const base = states[String(p.blockedState)];
+        if (base !== 'todo' && base !== 'doing')
+            throw bad(`blockedState : « ${String(p.blockedState)} » doit être un état todo ou doing`);
+        model.blocked = String(p.blockedState);
+    }
+    return { states: model };
+}
+/** L'état que prend un lot qui entre dans ce statut de base : `doneState` pour done, sinon le premier état déclaré de ce statut. */
+export function defaultState(model, base) {
+    if (base === 'done' && model.done)
+        return model.done;
+    return Object.keys(model.states).find((s) => model.states[s] === base);
+}
+/** L'état d'un lot : celui qu'il porte, sinon l'état par défaut de son statut (lot écrit avant la déclaration). */
+export function currentState(model, lot) {
+    return lot.state ?? defaultState(model, lot.status) ?? lot.status;
+}
+/** Pourquoi `from → to` est refusé par `plan.transitions` ; `null` quand c'est permis ou que rien n'est déclaré. */
+export function transitionProblem(model, from, to) {
+    if (!model.transitions)
+        return null;
+    const allowed = model.transitions[from];
+    if (allowed?.includes(to))
+        return null;
+    return `${from} → ${to} n'est pas permis (${allowed?.length ? `depuis ${from} : ${allowed.join(', ')}` : 'état terminal'})`;
+}
+/** Les écarts d'un état écrit à la main : état non déclaré, ou statut de base qui contredit `status:`. */
+export function stateProblems(model, lot) {
+    if (lot.state === undefined)
+        return [];
+    const base = Object.hasOwn(model.states, lot.state) ? model.states[lot.state] : undefined;
+    if (base === undefined)
+        return [`état « ${lot.state} » non déclaré (cadence.yaml : plan.states)`];
+    return base === lot.status ? [] : [`état « ${lot.state} » (${base}) contredit status: ${lot.status}`];
+}
+/**
+ * Applique à `node` le changement de statut de base de `raf status` : todo → doing démarre le lot, doing → todo le remet en attente
+ * (`started:` retiré) — refusé, comme `raf todo`, dès qu'un commit cite le lot : le remettre en attente perdrait leur lien. Rend le refus
+ * (`move` nomme le lot, l'état visé et son statut de base), `undefined` quand le changement est fait. Autre changement : rien n'est touché,
+ * le refus renvoie à sa commande.
+ */
+export function rebase(node, lot, move, today, commits) {
+    const { ref, to, base } = move;
+    if (lot.status === 'todo' && base === 'doing') {
+        node.set('status', 'doing');
+        if (!lot.started)
+            node.set('started', today);
+        return undefined;
+    }
+    if (lot.status === 'doing' && base === 'todo') {
+        const n = commits();
+        if (n > 0)
+            return `${ref} a ${n} commit(s) qui le citent : le remettre en attente perdrait leur lien — un état doing (raf status ${ref} <état>), ou raf drop ${ref}`;
+        node.set('status', 'todo');
+        node.delete('started');
+        return undefined;
+    }
+    const command = base === 'done' ? 'done' : base === 'dropped' ? 'drop' : 'todo';
+    return `${ref} : ${to} a pour statut de base ${base}, ${lot.status} aujourd'hui — passer par raf ${command} ${ref}`;
+}