@afokapu/atdd-bun 0.10.114 → 0.10.116

package/integrity.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.114",
+  "version": "0.10.116",
   "files": {
     "HOOK_AUDIT.md": "5329d840db37671b1918f688ead26865473b87db73dbc75f7c8b2a8bbe8d6d43",
     "README.md": "8aefceaa24bee498f39081b2aaf4c0d5c54bc1ed9849c20e1d98d1427df56eab",
@@ -1269,7 +1269,7 @@
     "src/cli.ts": "395638ab87565bb10c2beb35988ff1acf686924d13515795156a2e8893b3da88",
     "src/docs-capability.ts": "bdeeb414649049b1cd4fa8008cada3a576318be51c43bec91bfa46a8e250c270",
     "src/enforce.ts": "c4811abe63efe4568f3cf26e21a152d1537e120cb3ce471daca32367cf6e2cda",
-    "src/hooks.ts": "afda4062002846e56d4c3ed0e7d4e18d9dfd59666a25d55eee4b68221f3411ef",
+    "src/hooks.ts": "c7dcf6ddfa33d7b0c293e5400da679ec339242917746fba5e5213f8a267b8522",
     "src/index.ts": "4081f8b08d1d3ee9e15a9964143e53d9cfb94a5616ab3e58a180d24cc16dc381",
     "src/integrity.ts": "f1ede7cb04924ae88e11917047277e264af6596b9759e381bd9c497cd34a797d",
     "src/journey-docs.ts": "994d229376244c84212cff951032823068a76565dd2fd427b9d44e341bd14853",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afokapu/atdd-bun",
-  "version": "0.10.114",
+  "version": "0.10.116",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/afokapu/atdd-bun.git"

package/src/hooks.ts

@@ -479,7 +479,7 @@ export async function runHook(event: HookEvent, root = process.cwd(), args: stri
   if (event === "pre-commit") { const staged = await files(root, ["diff", "--cached", "--name-only"]), registries = staged.filter(path => isRegistry(cfg, path)), generated = staged.filter(isGeneratedView), counted = staged.length - registries.length - generated.length, lines = (await stagedLineStats(root)).filter(row => !isRegistry(cfg, row.path) && !isGeneratedView(row.path)).reduce((n, row) => n + row.added + row.removed, 0); const count = await stagedCountGate(root, staged, counted, cfg.max_staged_files); if (count.rejection) return bad(count.rejection); if (lines > cfg.max_staged_changed_lines) return bad(`staged changed lines ${lines} exceed ${cfg.max_staged_changed_lines}`); const ratchet = await ratchetCommitGate(root, staged, registries.length > 0); if (ratchet) return ratchet; const checked = cfg.require_traceability || registries.length || generated.length ? await validation(root, staged, false, registries.length > 0) : { ok: true, message: "ok" }; if (checked.ok && count.grant) await recordPendingException(root, count.grant); return checked; }
   if (event === "commit-msg") { const deleted = (await files(root, ["diff", "--cached", "--name-only", "--diff-filter=D"])).length, stats = await stagedStats(root), lines = stats.reduce((n, row) => n + row.removed, 0), registryRemoved = stats.filter(row => isRegistry(cfg, row.path)).reduce((n, row) => n + row.removed - row.added, 0), message = args[0] && existsSync(args[0]) ? await readFile(args[0], "utf8") : "", approved = message.includes("[mass-delete-approved]"); if ((deleted > 50 || lines > 10_000) && !approved) return bad("mass delete requires [mass-delete-approved]"); return registryRemoved > cfg.max_registry_removed_lines && !approved ? bad(`registry removal of ${registryRemoved} net lines exceeds ${cfg.max_registry_removed_lines}; requires [mass-delete-approved]`) : { ok: true, message: "ok" }; }
   if (event === "pre-push") { const reports: string[] = []; let exclusions: Awaited<ReturnType<typeof countExclusionTips>> | undefined; for (const row of stdin.split("\n").filter(Boolean).map(row => row.split(/\s+/))) { const [, local, remote, remoteSha] = row, target = remote?.replace("refs/heads/", ""); if (target && cfg.protected_branches.includes(target)) return bad(`protected branch ${target} is blocked`); if (!local) return bad("pre-push update has no local object id"); if (/^0+$/.test(local)) { const deletion = await deletionPushGate(root, remoteSha); if (!deletion.ok) return deletion; continue; } const isNew = !remoteSha || /^0+$/.test(remoteSha), range = isNew ? `${local}^..${local}` : `${remoteSha}..${local}`, shared = exclusions ??= await countExclusionTips(root, cfg.protected_branches, args[0]); if ("error" in shared) return bad(`could not list remote branch tips for the pushed range ${range}: ${shared.error}`); const counted = await git(root, ["rev-list", "--count", ...(shared.tips.length ? [isNew ? local : range, "--not", ...shared.tips] : [range])]); if (counted.code || !/^\d+$/.test(counted.out)) return bad(`could not count commits in pushed range ${range}: ${counted.err || counted.out}`); if (Number(counted.out) > cfg.max_commits_per_push) return bad(`commits per push ${counted.out} exceed ${cfg.max_commits_per_push}`); const ratchet = remote?.startsWith("refs/heads/") ? await ratchetPushGate(root, remoteSha ?? "", local, cfg.protected_branches, args[0]) : null; if (ratchet) { if (!ratchet.ok) return ratchet; reports.push(ratchet.message); continue; } const strict = await strictPushGate(root, local, range); if (!strict.ok) return strict; } return reports.length ? { ok: true, message: reports.length === 1 ? reports[0]! : `[${reports.join(",")}]` } : { ok: true, message: "validation clean" }; }
-  if (event === "post-commit") { await consumePendingException(root); const result = await validation(root, await files(root, ["show", "--pretty=format:", "--name-only", "HEAD"]), false); return { ok: true, message: result.ok ? result.message : `advisory: ${result.message}` }; }
+  if (event === "post-commit") { await consumePendingException(root); const result = await validation(root, await files(root, ["show", "--pretty=format:", "--name-only", "HEAD"]), false), advance = await advanceJjDeliveryBookmark(root, cfg), message = result.ok ? result.message : `advisory: ${result.message}`; return { ok: true, message: advance ? `${message}; ${advance}` : message }; }
   return { ok: true, message: "ok" };
 }
 
@@ -556,17 +556,72 @@ async function jjPrimaryOnBranch(primary: string, branch: string): Promise<boole
   return (await lines("@-")).length === 1 && (await lines(`@- & (bookmarks(exact:${name}) | remote_bookmarks(exact:${name}, exact:"origin"))`)).length === 1;
 }
 
-// A colocated JJ workspace keeps Git HEAD detached, so the named-branch condition is read from JJ:
-// @ must carry exactly one local, non-conflicted bookmark, and that same name must be the only
-// Git-exported branch at @ and not protected. `--ignore-working-copy` keeps the hook from snapshotting.
+const ADVANCE_ADVISORY = "delivery bookmark not advanced";
+const workingCopyTemplate = 'commit_id ++ "\\n" ++ empty ++ "\\n" ++ parents.map(|p| p.commit_id()).join(",") ++ "\\n" ++ local_bookmarks.map(|b| if(b.conflict(), "conflict:", "") ++ b.name()).join("\\n")';
+type WorkingCopy = { commit: string; empty: boolean; parents: string; bookmarks: string[] };
+// `--ignore-working-copy` reads the recorded operation state without snapshotting; omit it to snapshot first.
+async function jjWorkingCopy(root: string, ignoreWorkingCopy: boolean): Promise<WorkingCopy | null> {
+  const result = await jj(root, ["log", ...(ignoreWorkingCopy ? ["--ignore-working-copy"] : []), "--no-graph", "-r", "@", "-T", workingCopyTemplate]).catch(() => null);
+  if (!result || result.code) return null;
+  const [commit, empty, parents, ...bookmarks] = result.out.split("\n");
+  return { commit: commit ?? "", empty: empty === "true", parents: parents ?? "", bookmarks: bookmarks.filter(Boolean) };
+}
+
+// The one unambiguous delivery bookmark of a commit: exactly one local, non-conflicted, non-protected
+// bookmark that is also the only Git-exported branch at that commit.
+async function exactDeliveryBookmark(root: string, at: WorkingCopy, protectedBranches: string[]): Promise<{ name: string } | { error: string }> {
+  if (at.bookmarks.length !== 1) return { error: `the working-copy commit must carry exactly one bookmark; found ${at.bookmarks.length}` };
+  const name = at.bookmarks[0]!;
+  if (protectedBranches.includes(name)) return { error: `bookmark ${name} is protected` };
+  const exported = await branchForCommit(root, at.commit, []);
+  return "error" in exported || exported.branch !== name ? { error: `bookmark ${name} is conflicted or not the only exported branch at the working-copy commit` } : { name };
+}
+
+// A colocated JJ workspace keeps Git HEAD detached, so the named-branch condition is read from JJ: @ must
+// carry the exact delivery bookmark. Reading without a snapshot keeps the hook from mutating the working copy.
 async function jjDeliveryBookmarkAtWorkingCopy(root: string, protectedBranches: string[]): Promise<boolean> {
   if (!existsSync(join(root, ".jj"))) return false;
-  const at = await jj(root, ["log", "--ignore-working-copy", "--no-graph", "-r", "@", "-T", 'commit_id ++ "\\n" ++ local_bookmarks.map(|b| if(b.conflict(), "conflict:", "") ++ b.name()).join("\\n")']).catch(() => null);
-  if (!at || at.code) return false;
-  const [commit, ...bookmarks] = at.out.split("\n");
-  if (!commit || bookmarks.length !== 1) return false;
-  const exported = await branchForCommit(root, commit, []);
-  return !("error" in exported) && exported.branch === bookmarks[0] && !protectedBranches.includes(exported.branch);
+  const at = await jjWorkingCopy(root, true);
+  return !!at && "name" in await exactDeliveryBookmark(root, at, protectedBranches);
+}
+
+// `git commit` in a colocated JJ workspace leaves the delivery bookmark on the old empty working-copy commit,
+// a sibling of the validated commit, so `jj git push --bookmark` cannot publish it. Verify the validated commit
+// and the previous working copy, returning the one bookmark to move or the reason it must stay.
+async function advanceCandidate(root: string, protectedBranches: string[]): Promise<{ name: string; validated: string } | { error: string }> {
+  const [validated, ...gitParents] = (await git(root, ["rev-list", "--parents", "-n", "1", "HEAD"])).out.split(" ");
+  if (!validated || gitParents.length !== 1) return { error: "the validated HEAD must have exactly one parent" };
+  const old = await jjWorkingCopy(root, true);
+  if (!old || !old.empty || old.parents !== gitParents[0]) return { error: "the previous working-copy commit is not an empty sibling of the validated commit" };
+  const exact = await exactDeliveryBookmark(root, old, protectedBranches);
+  if ("error" in exact) return exact;
+  const now = await jjWorkingCopy(root, false);
+  return now?.empty && now.parents === validated ? { name: exact.name, validated } : { error: "the working copy is not an empty child of the validated commit" };
+}
+
+// The advance applies only to a detached colocated JJ workspace linked beneath the required worktree root.
+async function isLinkedJjDeliveryWorkspace(root: string, cfg: HookPolicy): Promise<boolean> {
+  if (!cfg.worktrees.enabled || !existsSync(join(root, ".jj"))) return false;
+  const state = await layout(root, cfg.worktrees);
+  return !("error" in state) && !state.branch && state.current !== state.primary && inside(state.worktreeRoot, state.current);
+}
+
+// Move the bookmark, then prove JJ and the Git ref both name exactly the validated commit; returns the failure or null.
+async function moveBookmarkVerified(root: string, name: string, validated: string): Promise<string | null> {
+  const moved = await jj(root, ["bookmark", "set", name, "-r", validated, "--allow-backwards"]);
+  const targets = await jj(root, ["log", "--ignore-working-copy", "--no-graph", "-r", `bookmarks(exact:${JSON.stringify(name)})`, "-T", 'commit_id ++ "\\n"']);
+  const aligned = !moved.code && targets.out === validated && (await branchCommit(root, name)) === validated;
+  return aligned ? null : `bookmark ${name} did not end at the validated commit ${validated}: ${moved.err || targets.out}`;
+}
+
+// After the validated commit, move exactly the eligible delivery bookmark to it. Returns null when the policy
+// does not apply, and an advisory (never a veto of the already-made commit) when ineligible; nothing moves then.
+async function advanceJjDeliveryBookmark(root: string, cfg: HookPolicy): Promise<string | null> {
+  if (!await isLinkedJjDeliveryWorkspace(root, cfg)) return null;
+  const candidate = await advanceCandidate(root, cfg.protected_branches);
+  if ("error" in candidate) return `${ADVANCE_ADVISORY}: ${candidate.error}`;
+  const failure = await moveBookmarkVerified(root, candidate.name, candidate.validated);
+  return failure ? `${ADVANCE_ADVISORY}: ${failure}` : `advanced delivery bookmark ${candidate.name} to ${candidate.validated}`;
 }
 
 type Layout = { primary: string; worktreeRoot: string; current: string };
@@ -628,13 +683,12 @@ async function finishCandidate(state: Layout, cfg: HookPolicy): Promise<{ error:
   const current = await currentCommit(state.current);
   if (!current) return { error: "could not resolve the current Jujutsu revision" };
   let delivery = current, found = await branchForCommit(state.current, current, cfg.protected_branches);
-  if ("error" in found && found.count === 0 && await mergedIntoPrimary(state, current, cfg)) return { branch: null, tip: current };
   if ("error" in found) {
+    // The established delivery path comes first: an empty working copy above a bookmarked parent.
     const changed = await jj(state.current, ["diff", "-r", "@", "--name-only"]);
     const parent = await jj(state.current, ["log", "-r", "@-", "--no-graph", "-T", "commit_id"]);
-    if (changed.code || changed.out || parent.code || !parent.out) return found;
-    const parentFound = await branchForCommit(state.current, parent.out, cfg.protected_branches);
-    if ("error" in parentFound) return found;
+    const parentFound = changed.code || changed.out || parent.code || !parent.out ? found : await branchForCommit(state.current, parent.out, cfg.protected_branches);
+    if ("error" in parentFound) return found.count === 0 && await chainToPrimary(state, current, cfg, true) === "merged" ? { branch: null, tip: current } : found;
     delivery = parent.out;
     found = parentFound;
   }
@@ -656,21 +710,33 @@ async function jjRevision(root: string, commit: string): Promise<{ error: string
   return { empty: emptiness === "empty", conflict: conflict === "conflict", parents };
 }
 
-// A tip is delivered when it is an ancestor of the protected branch, or when it
-// reaches such an ancestor only through empty single-parent changes (nothing to
-// deliver). Content, conflicts, or merge shapes outside that chain fail closed.
-async function deliveryError(state: Layout, branch: string, tip: string, cfg: HookPolicy): Promise<string | null> {
-  let commit = tip;
-  for (;;) {
+// Walks from a tip toward the protected branch through empty single-parent changes. "merged" means
+// the walk reached an ancestor of the protected branch, so there is nothing to deliver. Content,
+// conflicts, or merge shapes outside that chain fail closed. With refFree, an unmerged change that
+// carries any refs/heads bookmark (protected or not) also fails closed, so no unique ref is left behind.
+type ChainOutcome = "merged" | "conflict" | "unmerged" | { error: string };
+async function chainToPrimary(state: Layout, tip: string, cfg: HookPolicy, refFree = false): Promise<ChainOutcome> {
+  for (let commit = tip;;) {
     const info = await jjRevision(state.primary, commit);
-    if ("error" in info) return info.error;
-    if (info.conflict) return `bookmark ${branch} has unresolved conflicts`;
-    if (await mergedIntoPrimary(state, commit, cfg)) return null;
-    if (!info.empty || info.parents.length !== 1) return `branch ${branch} is not merged into ${cfg.worktrees.primary_branch} in the primary checkout`;
+    if ("error" in info) return info;
+    if (info.conflict) return "conflict";
+    if (await mergedIntoPrimary(state, commit, cfg)) return "merged";
+    if (!info.empty || info.parents.length !== 1) return "unmerged";
+    if (refFree) {
+      const refs = await git(state.primary, ["for-each-ref", "--format=%(refname)", "--points-at", commit, "refs/heads/"]);
+      if (refs.code || refs.out) return "unmerged";
+    }
     commit = info.parents[0]!;
   }
 }
 
+async function deliveryError(state: Layout, branch: string, tip: string, cfg: HookPolicy): Promise<string | null> {
+  const outcome = await chainToPrimary(state, tip, cfg);
+  if (outcome === "merged") return null;
+  if (outcome === "conflict") return `bookmark ${branch} has unresolved conflicts`;
+  return typeof outcome === "string" ? `branch ${branch} is not merged into ${cfg.worktrees.primary_branch} in the primary checkout` : outcome.error;
+}
+
 // The workspace name is never derived from the bookmark (bookmarks can be
 // renamed). Resolve it from the JJ registry: exactly one registered workspace
 // must resolve, by real path, to the current directory.