yadflow 3.18.1 → 4.0.0-next.1

package/cli/tidy.mjs

@@ -1,4 +1,4 @@
-// `yad tidy up` — fold FINISHED back-half shards back into their single folded ledger, on demand.
+// `yad tidy up` — fold FINISHED Build shards back into their single folded ledger, on demand.
 //
 // The two logs are shard-then-fold (cli/ledger.mjs): writers drop one loose file per entry so
 // concurrent writers never conflict. Left alone they accumulate; `yad tidy up` is the "pack it up"
@@ -9,11 +9,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { c, log, ok, info, fail, hand, exists, pushWithRebase } from './lib.mjs';
-import { PROJECT_FILES } from './manifest.mjs';
-import { loadHub } from './gate.mjs';
-import { resolveCommitterLogin } from './platform.mjs';
+import { productConfigPath } from './manifest.mjs';
+import { loadProduct } from './gate.mjs';
+import { platformLogin } from './platform.mjs';
 import { checkpointAuthor } from './checkpoint.mjs';
-import { hubGit, resolveDefaultBranch, guardDefaultBranch } from './hubcommit.mjs';
+import { productGit, resolveDefaultBranch, guardDefaultBranch } from './hubcommit.mjs';
 import { foldTrust, foldBuild } from './ledger.mjs';
 import { epicRoot, isValidEpicId, readFrontmatter } from './epic-state.mjs';
 
@@ -39,14 +39,14 @@ function epicsWithLedgers(root) {
 export async function runTidy(root, opts = {}) {
   log(c.bold('\nyad tidy up'));
   if (!exists(path.join(root, '.git'))) { fail('not a git repo'); process.exitCode = 1; return; }
-  if (!exists(path.join(root, PROJECT_FILES.hubConfig))) {
-    fail('no .sdlc/hub.json — run `yad tidy up` from the product hub');
+  if (!exists(productConfigPath(root))) {
+    fail('no .sdlc/hub.json — run `yad tidy up` from the Product');
     process.exitCode = 1;
     return;
   }
 
-  const { hub } = loadHub(root);
-  const git = hubGit(root);
+  const { hub } = loadProduct(root);
+  const git = productGit(root);
   const branch = git('rev-parse', '--abbrev-ref', 'HEAD').stdout;
   const defaultBranch = resolveDefaultBranch(git, hub);
   if (!guardDefaultBranch(branch, defaultBranch, { allowBranch: opts.allowBranch, cmd: 'yad tidy up' })) return;
@@ -68,16 +68,16 @@ export async function runTidy(root, opts = {}) {
       info(`${epic}: ${opts.dryRun ? 'would fold' : 'folded'} ${t.folded} trust + ${b.folded} build shard(s)`);
     }
   }
-  if (!folded) { info('nothing to tidy — no finished shards to fold'); return { folded: 0 }; }
+  if (!folded) { info('nothing to tidy — no finished shards to fold'); return { folded: 0, epics: [], message: null, committed: false, pushed: false, dryRun: !!opts.dryRun }; }
 
-  const author = checkpointAuthor(resolveCommitterLogin(root, hub?.roster || []), git('config', 'user.name').stdout);
+  const author = checkpointAuthor(platformLogin(root, hub?.platform), git('config', 'user.name').stdout);
   const label = touched.length === 1 ? touched[0] : `${touched.length} epics`;
-  const message = `chore(hub): tidy back-half ledgers — ${label} by ${author} [skip ci]`;
+  const message = `chore(hub): tidy Build ledgers — ${label} by ${author} [skip ci]`;
 
   if (opts.dryRun) {
     log('\n' + c.dim(message) + '\n');
     info('dry run — nothing folded or committed');
-    return { message, folded };
+    return { message, folded, epics: touched, committed: false, pushed: false, dryRun: true };
   }
 
   // Stage the fold (modified folded files + deleted shards) under each touched epic's ledger paths.
@@ -90,11 +90,11 @@ export async function runTidy(root, opts = {}) {
   });
   const pathspecs = candidates.filter((spec) =>
     exists(path.join(root, spec)) || git('ls-files', '--error-unmatch', '--', spec).ok);
-  if (!pathspecs.length) { info('fold produced no stageable change'); return { folded }; }
+  if (!pathspecs.length) { info('fold produced no stageable change'); return { message: null, folded, epics: touched, committed: false, pushed: false, dryRun: false }; }
   const add = git('add', '-A', '--', ...pathspecs);
-  if (!add.ok) { fail(`git add failed — ${add.stderr.split('\n')[0] || add.code}`); process.exitCode = 1; return { folded }; }
+  if (!add.ok) { fail(`git add failed — ${add.stderr.split('\n')[0] || add.code}`); process.exitCode = 1; return { message: null, folded, epics: touched, committed: false, pushed: false, dryRun: false }; }
   const staged = git('diff', '--cached', '--name-only', '--', ...pathspecs).stdout.split('\n').filter(Boolean);
-  if (!staged.length) { info('fold produced no net change — nothing to commit'); return { folded }; }
+  if (!staged.length) { info('fold produced no net change — nothing to commit'); return { message: null, folded, epics: touched, committed: false, pushed: false, dryRun: false }; }
 
   const cm = git('commit', '-m', message, '--', ...staged);
   if (!cm.ok) {
@@ -103,14 +103,14 @@ export async function runTidy(root, opts = {}) {
     fail(`git commit failed — ${cm.stderr.split('\n')[0] || cm.code}`);
     hand('the fold is staged — re-run `yad tidy up`, or `yad checkpoint` to land it');
     process.exitCode = 1;
-    return { message, folded };
+    return { message, folded, epics: touched, committed: false, pushed: false, dryRun: false };
   }
   ok(`tidied ${folded} shard(s) into ${touched.length} epic ledger(s): ${c.dim(label)}`);
 
-  if (!opts.push) return { message, folded };
-  if (pushWithRebase(root, branch).ok) { ok(`pushed to origin/${branch}`); return { message, folded }; }
+  if (!opts.push) return { message, folded, epics: touched, committed: true, pushed: false, dryRun: false };
+  if (pushWithRebase(root, branch).ok) { ok(`pushed to origin/${branch}`); return { message, folded, epics: touched, committed: true, pushed: true, dryRun: false }; }
   fail(`could not push to origin/${branch} — a protected branch, or an unresolvable rebase conflict`);
   hand(`run \`git pull --rebase\` and re-run \`yad tidy up --push\``);
   process.exitCode = 1;
-  return { message, folded };
+  return { message, folded, epics: touched, committed: true, pushed: false, dryRun: false };
 }

package/cli/update-commit.mjs

@@ -1,8 +1,8 @@
 // `yad update --push` / `yad check --fix --push` — after reconcile applies drift into the working
-// trees, commit the applied changes PER REPO (the hub and every connected repo) and push them
+// trees, commit the applied changes PER REPO (the Product and every connected repo) and push them
 // straight to the default branch, so a package update "just lands" everywhere instead of leaving
 // dirty trees for someone to hand-commit across N repos. This is the update-flow analogue of the
-// back-half `yad checkpoint` (cli/checkpoint.mjs) and reuses its machine-commit machinery.
+// Build `yad checkpoint` (cli/checkpoint.mjs) and reuses its machine-commit machinery.
 //
 // Invariants (shared with checkpoint):
 //   1. Stage an EXPLICIT per-repo allowlist — exactly the paths the reconcile actions declared they
@@ -23,24 +23,24 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { c, log, ok, info, warn, fail, hand, run, pushWithRebase } from './lib.mjs';
 import { VERSION } from './manifest.mjs';
-import { hubGit, resolveDefaultBranch } from './hubcommit.mjs';
+import { productGit, resolveDefaultBranch } from './hubcommit.mjs';
 
 // Collapse whitespace/newline runs to a single space — keeps a stray path or hostile value from
 // breaking the one-line subject or injecting a fake trailer line.
 const oneLine = (s = '') => String(s).replace(/\s+/g, ' ').trim();
 
-// A short, human label for a repo root relative to the hub: 'hub' for the hub itself, else the
+// A short, human label for a repo root relative to the Product: 'hub' for the Product itself, else the
 // registered path (e.g. demo-repos/backend), else the basename.
-export function repoLabel(hubRoot, root) {
-  if (root === hubRoot) return 'hub';
-  const r = path.relative(hubRoot, root);
+export function repoLabel(productRoot, root) {
+  if (root === productRoot) return 'hub';
+  const r = path.relative(productRoot, root);
   return r && !r.startsWith('..') ? r.split(path.sep).join('/') : path.basename(root);
 }
 
 // PURE — group applied reconcile actions by the repo root they wrote to. Each group carries the
 // deduped pathspecs to stage plus the human-readable item labels for the commit body. Actions with
 // no root/paths (e.g. gaps, or a status:'ok' that was force-reapplied without a root) are ignored.
-// Order follows first-encounter, so the hub (its module/_bmad/hub actions come first in reconcile)
+// Order follows first-encounter, so the Product (its module and Product actions come first in reconcile)
 // leads and connected repos follow in registry order.
 export function groupByRoot(actions = []) {
   const groups = new Map();
@@ -94,14 +94,14 @@ function stageAllowlist(git, root, paths) {
 // Commit (and, with push, push) one repo group. `defaultBranch` is the repo's configured default
 // (hub.default_branch / repo.default_branch); falls back to origin/HEAD then 'main'. Returns a small
 // result object; never throws. On any hard error it sets process.exitCode so the CLI reports failure.
-export function commitAndPush(group, { push = false, allowBranch = false, hubRoot, defaultBranch } = {}) {
+export function commitAndPush(group, { push = false, allowBranch = false, productRoot, defaultBranch } = {}) {
   const { root, paths, items } = group;
-  const label = repoLabel(hubRoot ?? root, root);
-  const git = hubGit(root);
+  const label = repoLabel(productRoot ?? root, root);
+  const git = productGit(root);
 
   // `root` must be the TOP of its OWN git repo — not merely "inside a work tree". A registered repo
   // whose clone is missing (reconcile's apply() happily recreates the wiring files) but whose path
-  // sits under the hub would otherwise report inside-work-tree=true against the HUB: git resolves the
+  // sits under the Product would otherwise report inside-work-tree=true against the HUB: git resolves the
   // pathspecs relative to cwd, so we would stage the connected repo's files into the HUB's index and
   // push them to the HUB's remote, mislabeled. Require the worktree top to BE this root.
   const top = git('rev-parse', '--show-toplevel');
@@ -110,7 +110,7 @@ export function commitAndPush(group, { push = false, allowBranch = false, hubRoo
   })();
   if (!sameRepo) {
     warn(`${label}: not its own git repo (missing/renamed clone?) — skipped (changes left in the working tree)`);
-    return { label, committed: false, skipped: true };
+    return { label, committed: false, pushed: false, skipped: true, error: false };
   }
   const branch = git('rev-parse', '--abbrev-ref', 'HEAD').stdout;
   const target = defaultBranch || resolveDefaultBranch(git);
@@ -120,13 +120,13 @@ export function commitAndPush(group, { push = false, allowBranch = false, hubRoo
       warn(`${label}: on '${branch}', not default '${target}' — --allow-branch: commit/push go to origin/${branch}`);
     } else {
       warn(`${label}: on '${branch}', not the default branch '${target}' — skipped (switch to '${target}' or pass --allow-branch)`);
-      return { label, committed: false, skipped: true };
+      return { label, committed: false, pushed: false, skipped: true, error: false };
     }
   }
 
   const { staged, addError } = stageAllowlist(git, root, paths);
   if (addError) warn(`${label}: git add reported "${addError}" — staging may be incomplete`);
-  if (!staged.length) { info(`${label}: nothing to commit (unchanged or ignored)`); return { label, committed: false }; }
+  if (!staged.length) { info(`${label}: nothing to commit (unchanged or ignored)`); return { label, committed: false, pushed: false, skipped: false, error: false }; }
 
   // Pushing HEAD lands any local commits ahead of the remote too. Warn before we add ours so the
   // operator sees unpublished WIP about to ride the update push (never silently publish it).
@@ -142,27 +142,27 @@ export function commitAndPush(group, { push = false, allowBranch = false, hubRoo
     git('reset', '-q', '--', ...staged); // don't leave our allowlist staged for an unrelated commit to sweep up
     fail(`${label}: git commit failed — ${cm.stderr.split('\n')[0] || cm.code}`);
     process.exitCode = 1;
-    return { label, committed: false, error: true };
+    return { label, committed: false, pushed: false, skipped: false, error: true };
   }
   ok(`${label}: committed ${staged.length} file(s)`);
 
-  if (!push) return { label, committed: true };
-  if (pushWithRebase(root, branch).ok) { ok(`${label}: pushed to origin/${branch}`); return { label, committed: true, pushed: true }; }
+  if (!push) return { label, committed: true, pushed: false, skipped: false, error: false };
+  if (pushWithRebase(root, branch).ok) { ok(`${label}: pushed to origin/${branch}`); return { label, committed: true, pushed: true, skipped: false, error: false }; }
   // The commit already landed locally — a re-run of `yad update --push` would see no drift and skip
   // this repo, so point the operator at the direct push of the commit that already exists.
   fail(`${label}: could not push to origin/${branch} — a protected branch, or an unresolvable rebase conflict`);
   hand(`resolve it in ${label === 'hub' ? '.' : label}, then push the existing commit with \`git push origin ${branch}\``);
   process.exitCode = 1;
-  return { label, committed: true, pushed: false, error: true };
+  return { label, committed: true, pushed: false, skipped: false, error: true };
 }
 
 // Orchestrate the per-repo commit/push over the grouped applied actions, bookended by the announce
 // banners. `defaultBranchFor(root)` yields each repo's configured default branch (undefined ->
 // resolve from the remote). Prints, commits/pushes each group, then the done banner.
-export function commitUpdates(hubRoot, groups, { push = false, allowBranch = false, defaultBranchFor, guardInactiveGitlab } = {}) {
+export function commitUpdates(productRoot, groups, { push = false, allowBranch = false, defaultBranchFor, guardInactiveGitlab } = {}) {
   if (!groups.length) { info('no committable changes were applied'); return []; }
 
-  const labels = groups.map((g) => repoLabel(hubRoot, g.root));
+  const labels = groups.map((g) => repoLabel(productRoot, g.root));
   log('');
   log(c.bold(`yad update — ${push ? 'publishing to default branches' : 'committing locally (no --push)'}`));
   warn(`about to ${push ? 'commit + push directly to the default branch' : 'commit'} on: ${labels.join(', ')}`);
@@ -170,7 +170,7 @@ export function commitUpdates(hubRoot, groups, { push = false, allowBranch = fal
 
   const results = [];
   for (const g of groups) {
-    const r = commitAndPush(g, { push, allowBranch, hubRoot, defaultBranch: defaultBranchFor?.(g.root) });
+    const r = commitAndPush(g, { push, allowBranch, productRoot, defaultBranch: defaultBranchFor?.(g.root) });
     if (push && r.pushed && guardInactiveGitlab?.(g.root)) {
       hand(`${r.label}: GitLab yad-update-guard is not active — add \`- local: '.gitlab/ci/yad-update-guard.yml'\` to the root .gitlab-ci.yml include (re-run the yad-checks wire step) so this direct-to-default push is gated`);
     }