@tablation/crew 0.18.0 → 0.19.1

package/dist/cli.js

@@ -2575,6 +2575,9 @@ function detectSystemd() {
   return !res.error;
 }
 
+// src/ship-attention.ts
+import { statfsSync } from "fs";
+
 // src/git.ts
 import { execFileSync } from "child_process";
 import {
@@ -2732,7 +2735,20 @@ function patchIdOf(cwd, from, to) {
     return null;
   }
 }
+var BRANCH_TIP_TRAILER = "Branch-tip";
+function findSquashByBranchTip(cwd, key, branch, range) {
+  const tip = gitOk(cwd, ["rev-parse", "--verify", "-q", `${branch}^{commit}`]);
+  if (!tip) return null;
+  const wanted = `${BRANCH_TIP_TRAILER}: ${tip}`;
+  for (const sha of keyCommitsInRange(cwd, key, range)) {
+    const body = gitOk(cwd, ["show", "-s", "--format=%B", sha]) ?? "";
+    if (body.split("\n").some((l) => l.trim() === wanted)) return sha;
+  }
+  return null;
+}
 function findSquashOfBranch(cwd, key, branch, base, range) {
+  const byTip = findSquashByBranchTip(cwd, key, branch, range);
+  if (byTip) return byTip;
   const candidates = keyCommitsInRange(cwd, key, range);
   if (candidates.length === 0) return null;
   const mb = gitOk(cwd, ["merge-base", base, branch]);
@@ -3049,14 +3065,94 @@ function baseAttention(repo, outcome, remote, base, nowIso = (/* @__PURE__ */ ne
   if (outcome.action === "level" || outcome.action === "fast-forwarded") return { clear: baseUnsafeKey(repo) };
   return null;
 }
+var diskLowKey = (repo) => `disk_low:${repo}`;
+var LOW_DISK_BYTES = 2 * 1024 ** 3;
+var gib = (bytes) => (bytes / 1024 ** 3).toFixed(1);
+function diskAttention(repo, freeBytes, thresholdBytes = LOW_DISK_BYTES, nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (freeBytes >= thresholdBytes) return { clear: diskLowKey(repo) };
+  return {
+    raise: {
+      kind: "disk_low",
+      key: diskLowKey(repo),
+      since: nowIso,
+      message: `${repo}: only ${gib(freeBytes)} GiB free beside the checkout (need ${gib(thresholdBytes)}) \u2014 no worktree can be set up until space is freed. Resumes automatically once there is room`
+    }
+  };
+}
+function freeBytesAt(dir) {
+  try {
+    const s = statfsSync(dir);
+    return Number(s.bavail) * Number(s.bsize);
+  } catch {
+    return null;
+  }
+}
+async function checkRepoDisks(o, freeAt = freeBytesAt, thresholdBytes = LOW_DISK_BYTES) {
+  for (const target of reposOf(o.route)) {
+    const free = freeAt(target.dir);
+    if (free === null) continue;
+    const att = diskAttention(target.name, free, thresholdBytes);
+    if ("raise" in att) await raiseShipAttention(o, att.raise);
+    else clearShipAttention(o.state, att.clear);
+  }
+}
+function parseHookMissing(key, routeName) {
+  const prefix = `hook_missing:${routeName}/`;
+  if (!key.startsWith(prefix)) return null;
+  const rest = key.slice(prefix.length);
+  const slash = rest.lastIndexOf("/");
+  if (slash <= 0) return null;
+  return { repo: rest.slice(0, slash), hook: rest.slice(slash + 1) };
+}
 function repoStopFor(items, route) {
-  const stops = new Map(items.filter((i) => i.kind === "base_unsafe").map((i) => [i.key, i.message]));
+  const stops = /* @__PURE__ */ new Map();
+  for (const i of items) {
+    let repo = null;
+    if (i.kind === "base_unsafe") repo = i.key.slice("base_unsafe:".length);
+    else if (i.kind === "disk_low") repo = i.key.slice("disk_low:".length);
+    else if (i.kind === "hook_missing") {
+      const h = parseHookMissing(i.key, route.route);
+      if (h?.hook === "setup") repo = h.repo;
+    }
+    if (repo && !stops.has(repo)) stops.set(repo, i.message);
+  }
   if (stops.size === 0) return () => null;
   return (t) => {
     const name = repoTargetFor(route, t.repo_id)?.name;
-    return name ? stops.get(baseUnsafeKey(name)) ?? null : null;
+    return name ? stops.get(name) ?? null : null;
   };
 }
+function recheckEnvironmentStops(state, route, ship, deps = {}) {
+  const onPath = deps.onPath ?? findOnPath;
+  const dockerProblem = deps.dockerProblem ?? dockerPathProblem;
+  const cleared = [];
+  for (const item of state.shipAttention().previous()) {
+    if (item.kind === "docker_missing") {
+      if (!dockerProblem(ship)) {
+        clearShipAttention(state, item.key);
+        cleared.push("docker");
+      }
+      continue;
+    }
+    if (item.kind !== "hook_missing") continue;
+    const h = parseHookMissing(item.key, route.route);
+    const target = h && reposOf(route).find((t) => t.name === h.repo);
+    if (!h || !target) continue;
+    let cfg;
+    try {
+      cfg = resolveRepoConfig(loadRepoConfig(target.dir), void 0, target.dir);
+    } catch {
+      continue;
+    }
+    const script = cfg.hooks[h.hook];
+    const cmd = script ? hookCommand(script) : null;
+    if (!cmd || onPath(cmd, pathFor(ship))) {
+      clearShipAttention(state, item.key);
+      cleared.push(`${h.repo}/${h.hook}`);
+    }
+  }
+  return cleared;
+}
 function recheckBaseStops(state, route) {
   const open = state.shipAttention().previous().filter((i) => i.kind === "base_unsafe");
   const cleared = [];
@@ -4695,6 +4791,10 @@ async function decideCycle(o) {
   for (const repo of recheckBaseStops(state, route)) {
     emit.emit(`${repo}: primary checkout is level again \u2014 building lanes resume for that repo`, { step: "select" });
   }
+  for (const what of recheckEnvironmentStops(state, route, ship)) {
+    emit.emit(`${what}: no longer missing from the scheduler PATH \u2014 stop cleared`, { step: "select" });
+  }
+  await checkRepoDisks({ state, emit, route, ship });
   const selectionInput = {
     repoStop: repoStopFor(openShipAttention(state), route),
     tickets,
@@ -6391,14 +6491,9 @@ function planMerge(cwd, tickets, contract, lastReleased, branchFor = (t) => bran
         skipReason: "never-built"
       };
     }
-    const squash = findSquashOfBranch(
-      cwd,
-      referenceKeys(ticket),
-      branch,
-      base,
-      lastReleased ? `${lastReleased}..${base}` : base
-    );
+    const squash = findSquashOfBranch(cwd, referenceKeys(ticket), branch, base, base);
     if (squash) {
+      const released = !!lastReleased && isAncestor(cwd, squash, lastReleased);
       return {
         ticket,
         branch,
@@ -6406,7 +6501,7 @@ function planMerge(cwd, tickets, contract, lastReleased, branchFor = (t) => bran
         usedFallback: false,
         bump: "patch",
         majorRequested: false,
-        skipReason: "already-merged",
+        skipReason: released ? "already-released" : "already-merged",
         mergedSha: squash
       };
     }
@@ -6424,6 +6519,20 @@ function planMerge(cwd, tickets, contract, lastReleased, branchFor = (t) => bran
     };
   });
 }
+function planReleasedBranches(cwd, tickets, contract, branchFor, base = "main", tagPattern = "v*") {
+  const eligible = /* @__PURE__ */ new Set([contract.statuses.building, contract.statuses.needsHuman]);
+  const out = [];
+  for (const ticket of tickets) {
+    if (!eligible.has(ticket.status)) continue;
+    const branch = branchFor(ticket);
+    if (!branch) continue;
+    const sha = findSquashByBranchTip(cwd, referenceKeys(ticket), branch, base);
+    if (!sha) continue;
+    const tag = firstReleaseTagContaining(cwd, sha, tagPattern);
+    if (tag) out.push({ ticket, sha, tag });
+  }
+  return out;
+}
 function requestedBump(bodies) {
   const asks = [...bodies.matchAll(BUMP_LINE)].map((m) => m[1].toLowerCase());
   const majorRequested = asks.includes("major");
@@ -6886,9 +6995,13 @@ function mergeOne(o, c) {
       );
       return "noop";
     }
+    const tip = gitOk(o.cwd, ["rev-parse", "--verify", "-q", `${c.branch}^{commit}`]);
+    const trailer = tip ? `
+
+${BRANCH_TIP_TRAILER}: ${tip}` : "";
     git(o.cwd, ["commit", "-m", `${subject}
 
-Closes ${c.ticket.issue_id}.`]);
+Closes ${c.ticket.issue_id}.${trailer}`]);
     const sha = headSha(o.cwd);
     o.emit.emit(`merged ${c.branch}`, { ticket: c.ticket.issue_id });
     return { applied: true, sha };
@@ -10903,6 +11016,25 @@ ${changed2.map((c) => `  - ${c}
           target.dir
         );
       }
+      for (const r of planReleasedBranches(
+        target.dir,
+        tickets,
+        tracker.contract,
+        (t) => locateBranchForTicket(target.dir, repo, t)?.branch ?? null,
+        repo.branch.base,
+        repo.release.tagPattern ?? "v*"
+      )) {
+        remit.enter("reconcile");
+        await applyStamp(
+          tracker,
+          [{ ticket: r.ticket, reason: `branch already released in ${r.tag}`, sha: r.sha }],
+          r.tag.replace(/^v/, ""),
+          tracker.contract,
+          remit,
+          dryRun,
+          target.dir
+        );
+      }
       if (outcome.gateRed && !dryRun) {
         try {
           const g = outcome.gateRed;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.18.0",
+  "version": "0.19.1",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",