@sylad/cadence 1.42.1 → 1.43.0

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "cadence",
       "description": "Session start and close rituals driven by a versioned plan (raf), and deliveries proven by their effect. Needs the cadence CLI (npm i -g @sylad/cadence).",
-      "version": "1.42.1",
+      "version": "1.43.0",
       "source": "./",
       "author": {
         "name": "Sylvain Ladoire"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cadence",
   "description": "A repo-native working method: session start and close rituals driven by a versioned plan (raf), deliveries proven by their effect, and three reviewer agents (UX, code, QA).",
-  "version": "1.42.1",
+  "version": "1.43.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/dist/orchestrate/command-args.js

@@ -0,0 +1,138 @@
+import { isDay } from '../dates.js';
+import { RafError } from '../plan.js';
+import { parsePriority } from './continue.js';
+import { resumeCommand } from './table.js';
+/** Sessions simultanées, toutes vagues confondues (`--max-sessions`, ou CADENCE_MAX_SESSIONS). */
+export const DEFAULT_MAX_SESSIONS = 2;
+/** `1500000`, `1.5M`, `800k`. */
+export function parseBudget(text) {
+    const m = /^(\d+(?:[.,]\d+)?)\s*([kKmM]?)$/.exec(text.trim());
+    if (!m)
+        throw new RafError(`--budget invalide : ${text} (1500000, 1.5M, 800k)`);
+    const n = Number(m[1].replace(',', '.')) * ({ '': 1, k: 1e3, m: 1e6 }[m[2].toLowerCase()]);
+    if (!(n > 0))
+        throw new RafError(`--budget invalide : ${text}`);
+    return Math.round(n);
+}
+export function parseMaxSessions(text, what = '--max-sessions') {
+    if (!/^\d+$/.test(text.trim()) || Number(text) < 1)
+        throw new RafError(`${what} invalide : ${text} (entier ≥ 1)`);
+    return Number(text);
+}
+// une vague (2026-10-04-1412) n'a ni « : » ni « / » : leur présence désigne un lot, quel que soit son motif (R-M7/ux-1)
+export const LOT_LIKE = /^(?:[\w.-]+(?:\/[\w.-]+)*:[\w.-][\w./-]*|[\w.-]+\/[\w./-]*|[A-Za-z]+\d+)(?:@[\w.-]+)?$/;
+function lotArg(text) {
+    // le premier « : » sépare le projet du lot, un « @ » final le modèle ; le lot garde ses « / » (L120), le projet peut être un chemin depuis le dossier (`groupe/gamma`, projet imbriqué de lead tour --depth, L201)
+    const m = /^(?:([\w.-]+(?:\/[\w.-]+)*):)?([\w.-][\w./-]*?)(?:@([\w.-]+))?$/.exec(text);
+    if (!m)
+        throw new RafError(`lot invalide : ${text} (projet:lot, lot, projet:lot@haiku ; @ suivi d'un alias ou d'un nom de modèle)`);
+    return { project: m[1], lot: m[2], model: m[3] };
+}
+/** `projet:lot=+200k`, `lot=+0.3M` (L223) : le « = » distingue le relèvement d'un lot du budget de la vague. */
+function lotBudgetArg(text) {
+    const bad = () => new RafError(`--budget invalide : ${text} (projet:lot=+500k)`);
+    const m = /^([^=]+)=\+(.+)$/.exec(text);
+    if (!m)
+        throw bad();
+    let target;
+    let raise;
+    try {
+        target = lotArg(m[1]);
+        raise = parseBudget(m[2]);
+    }
+    catch {
+        throw bad();
+    }
+    if (target.model)
+        throw bad();
+    return { project: target.project, lot: target.lot, raise, text: m[2] };
+}
+export function parseOrchestrateArgs(argv) {
+    const a = { lots: [], lotBudgets: [], dryRun: false, waits: false, watch: false, continue: false, answers: [], drop: [], stopAfterCurrent: false, add: [], integrate: [], abandonCommits: false };
+    const optional = (i) => (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-') && !LOT_LIKE.test(argv[i + 1]) ? argv[i + 1] : undefined);
+    for (let i = 0; i < argv.length; i++) {
+        const t = argv[i];
+        const value = (flag) => {
+            if (argv[i + 1] === undefined)
+                throw new RafError(`${flag} attend une valeur`);
+            return argv[++i];
+        };
+        if (t === '--dry-run')
+            a.dryRun = true;
+        else if (t === '--status' || t === '--resume') {
+            const v = optional(i);
+            if (v !== undefined)
+                i++;
+            a[t === '--status' ? 'status' : 'resume'] = v ?? true;
+        }
+        else if (t === '--waits')
+            a.waits = true;
+        else if (t === '--since') {
+            a.since = value(t);
+            if (!isDay(a.since))
+                throw new RafError(`--since invalide : ${a.since} (AAAA-MM-JJ)`);
+        }
+        else if (t === '--detail')
+            a.detail = value(t);
+        else if (t === '--watch')
+            a.watch = true;
+        else if (t === '--interval')
+            a.interval = parseMaxSessions(value(t), '--interval');
+        else if (t === '--budget') {
+            const v = value(t);
+            if (v.includes('='))
+                a.lotBudgets.push(lotBudgetArg(v));
+            else
+                a.budget = parseBudget(v);
+        }
+        else if (t === '--max-sessions')
+            a.maxSessions = parseMaxSessions(value(t));
+        else if (t === '--goal') {
+            // Un texte oublié ne doit pas avaler l'option suivante (`--goal --dry-run` lancerait une vraie vague payante).
+            const next = argv[i + 1];
+            if (next?.startsWith('--'))
+                throw new RafError(`--goal attend un texte, pas l'option ${next}`);
+            a.goal = value(t).trim();
+            if (a.goal === '')
+                throw new RafError('--goal attend un texte non vide');
+        }
+        else if (t === '--wave')
+            a.wave = value(t);
+        else if (t === '--drop')
+            a.drop.push(lotArg(value(t)));
+        else if (t === '--stop-after-current')
+            a.stopAfterCurrent = true;
+        else if (t === '--add')
+            a.add.push(lotArg(value(t)));
+        else if (t === '--integrate')
+            a.integrate.push(lotArg(value(t)));
+        else if (t === '--replay')
+            a.integrate.push({ ...lotArg(value(t)), replay: true });
+        else if (t === '--remove-worktree')
+            a.removeWorktree = lotArg(value(t));
+        else if (t === '--abandon-commits')
+            a.abandonCommits = true;
+        else if (t === '--continue')
+            a.continue = true;
+        else if (t === '--until')
+            a.until = value(t);
+        else if (t === '--priority')
+            a.priority = parsePriority(value(t));
+        else if (t === '--answer') {
+            const target = lotArg(value(t));
+            a.answers.push({ project: target.project, lot: target.lot, text: value(t) });
+        }
+        else if (t.startsWith('-'))
+            throw new RafError(`option inconnue : ${t}`);
+        else
+            a.lots.push(lotArg(t));
+    }
+    // L309 : --wave <id> après un --resume sans valeur désigne la vague à reprendre ; sans cela le --resume reprenait en silence une AUTRE vague.
+    if (a.resume !== undefined && a.wave !== undefined) {
+        if (a.resume === true)
+            a.resume = a.wave;
+        else if (a.resume !== a.wave)
+            throw new RafError(`--resume ${a.resume} et --wave ${a.wave} désignent deux vagues : une seule (${resumeCommand('<vague>')})`);
+    }
+    return a;
+}