@helmsmith/workbrokr 0.2.0 → 0.3.0

package/dist/core/index.js

@@ -31,7 +31,8 @@ var REFUSALS = /* @__PURE__ */ new Set([
   "PORT_RANGE_TAKEN",
   "SYNC_CONFLICT",
   "DIRTY_WORKTREE",
-  "UNPUSHED"
+  "UNPUSHED",
+  "PR_CLOSED"
 ]);
 function exitCodeFor(code) {
   return REFUSALS.has(code) ? 2 : 1;
@@ -134,12 +135,27 @@ var Git = class _Git {
     else if (this.remoteBranchExists(this.currentBranch())) ref = `origin/${this.currentBranch()}`;
     return this.lines(["rev-list", `${ref}..HEAD`]).length;
   }
+  /** Commits on origin/<base> that HEAD does not have (0 when the ref is unknown). */
+  behindCount(base) {
+    const r = this.tryRun(["rev-list", "--count", `HEAD..origin/${base}`]);
+    return r.code === 0 ? Number(r.out.trim()) || 0 : 0;
+  }
   isDirty() {
     return this.run(["status", "--porcelain"]).trim().length > 0;
   }
   changedPathsStaged() {
     return this.lines(["diff", "--cached", "--name-only"]);
   }
+  /** The other parent of a merge in progress, or undefined when none is. */
+  mergeHead() {
+    const r = this.tryRun(["rev-parse", "-q", "--verify", "MERGE_HEAD"]);
+    return r.code === 0 ? r.out.trim() : void 0;
+  }
+  /** Staged paths whose index content differs from `ref` (so, authored here rather than taken from `ref`). */
+  stagedDifferingFrom(ref, paths) {
+    if (paths.length === 0) return [];
+    return this.lines(["diff", "--cached", "--name-only", "--no-renames", ref, "--", ...paths]);
+  }
   changedPaths(from, to) {
     return this.lines(["diff", "--name-only", "--no-renames", from, to]);
   }
@@ -172,18 +188,45 @@ var Git = class _Git {
     const conflicted = this.lines(["diff", "--name-only", "--diff-filter=U"]);
     return { kind: "conflict", before, after: before, conflicted };
   }
+  /** `origin/<branch>` after a fetch attempt, when the remote has it; the local copy may have been retired. */
+  remoteRef(branch) {
+    this.tryRun(["fetch", "-q", "origin", branch]);
+    const ref = `refs/remotes/origin/${branch}`;
+    return this.tryRun(["rev-parse", "--verify", "-q", ref]).code === 0 ? `origin/${branch}` : void 0;
+  }
+  /**
+   * Add a worktree on `branch`: the local branch if it exists, else a tracking
+   * branch from origin/<branch> if the remote has it (so retiring the local
+   * branch while its PR was open never recreates it from the base), else a
+   * new branch from `startPoint`.
+   */
   worktreeAdd(path, branch, startPoint) {
     mkdirSync(dirname(path), { recursive: true });
-    if (this.branchExists(branch)) this.run(["worktree", "add", "-q", path, branch]);
-    else
-      this.run(["worktree", "add", "-q", "--no-track", "-b", branch, path, startPoint ?? "HEAD"]);
+    if (this.branchExists(branch)) {
+      this.run(["worktree", "add", "-q", path, branch]);
+      return;
+    }
+    const remote = this.remoteRef(branch);
+    if (remote) {
+      this.run(["worktree", "add", "-q", "--track", "-b", branch, path, remote]);
+      return;
+    }
+    this.run(["worktree", "add", "-q", "--no-track", "-b", branch, path, startPoint ?? "HEAD"]);
   }
   worktreeRemove(path) {
     this.run(["worktree", "remove", "--force", path]);
   }
   checkout(branch, createFrom) {
-    if (this.branchExists(branch)) this.run(["checkout", "-q", branch]);
-    else this.run(["checkout", "-q", "--no-track", "-b", branch, createFrom ?? "HEAD"]);
+    if (this.branchExists(branch)) {
+      this.run(["checkout", "-q", branch]);
+      return;
+    }
+    const remote = this.remoteRef(branch);
+    if (remote) {
+      this.run(["checkout", "-q", "--track", "-b", branch, remote]);
+      return;
+    }
+    this.run(["checkout", "-q", "--no-track", "-b", branch, createFrom ?? "HEAD"]);
   }
   push(branch) {
     this.run(["push", "-q", "-u", "origin", branch]);
@@ -297,13 +340,14 @@ function slotVars(m, o) {
     BRANCH: o.branch ?? "",
     WORKTREE: o.worktree ?? "",
     LOG_DIR: o.logDir ?? "",
-    PORT_STORYBOOK: o.storybookPort === void 0 ? "" : String(o.storybookPort),
     STORYBROKR_HOST: storybookHostFor(m, o.worktree)
   };
   for (const service of Object.keys(m.ports.services)) {
     const p = o.ports[service];
     vars[`PORT_${service.toUpperCase()}`] = p === void 0 ? "" : String(p);
   }
+  if (o.storybookPort !== void 0) vars.PORT_STORYBOOK = String(o.storybookPort);
+  else if (vars.PORT_STORYBOOK === void 0) vars.PORT_STORYBOOK = "";
   return vars;
 }
 function ensureExcluded(worktree, patterns) {
@@ -541,8 +585,15 @@ function checkCommit(c) {
       `branch "${c.branch}" is protected (${c.m.protectedBranches.join(", ")}): work happens on <type>/<area> branches, never here`
     );
   }
+  const mergeHead = c.git.mergeHead();
+  const authored = mergeHead ? new Set(c.git.stagedDifferingFrom(mergeHead, c.stagedPaths)) : new Set(c.stagedPaths);
+  const ownPaths = c.stagedPaths.filter((p) => authored.has(p));
   const allEfforts = c.registry.efforts({ project: c.project });
   const efforts = new Map(allEfforts.map((e) => [e.id, e]));
+  const openEfforts = allEfforts.filter((e) => e.state === "active" || e.state === "starting");
+  const mine = openEfforts.find(
+    (e) => c.checkoutRoot && existsSync3(e.worktree) ? same(e.worktree, c.checkoutRoot) : e.branch === c.branch
+  );
   for (const lease of c.registry.leases({ project: c.project, kind: "commons" })) {
     const holder = efforts.get(lease.effort);
     const holderHasWorktree = Boolean(holder && existsSync3(holder.worktree));
@@ -551,34 +602,31 @@ function checkCommit(c) {
     } else if (lease.owner.session === c.ownerSession) {
       continue;
     }
+    if (holder && mine && holder.area === mine.area) continue;
     const globs = c.m.commons[String(lease.value)] ?? [];
-    const hit = pathsMatching(c.stagedPaths, globs);
+    const hit = pathsMatching(ownPaths, globs);
     if (hit.length > 0) {
       refusals.push(
         `commons "${lease.value}" is write-locked by ${lease.owner.session} (effort ${lease.effort}, since ${lease.touched}); staged: ${hit.join(", ")}`
       );
     }
   }
-  const openEfforts = allEfforts.filter((e) => e.state === "active" || e.state === "starting");
   for (const other of openEfforts) {
     if (c.checkoutRoot && existsSync3(other.worktree) && same(other.worktree, c.checkoutRoot)) {
       continue;
     }
     if (!c.checkoutRoot && other.branch === c.branch) continue;
-    const hit = pathsMatching(c.stagedPaths, other.scopes);
+    const hit = pathsMatching(ownPaths, other.scopes);
     if (hit.length > 0) {
       refusals.push(
         `path(s) ${hit.join(", ")} are inside the active scope of ${effortLabel(other)} (${other.branch}, owned by ${other.owner.session})`
       );
     }
   }
-  const mine = openEfforts.find(
-    (e) => c.checkoutRoot && existsSync3(e.worktree) ? same(e.worktree, c.checkoutRoot) : e.branch === c.branch
-  );
-  if (mine && c.stagedPaths.length > 0) {
+  if (mine && ownPaths.length > 0) {
     const allowed = allowedScopesForEffort(c.m, mine);
-    const inScope = new Set(pathsMatching(c.stagedPaths, allowed));
-    const outside = c.stagedPaths.filter((p) => !inScope.has(p));
+    const inScope = new Set(pathsMatching(ownPaths, allowed));
+    const outside = ownPaths.filter((p) => !inScope.has(p));
     if (outside.length > 0) {
       warnings.push(
         `${outside.length} staged path(s) are outside the effort's scope (${effortLabel(mine)}): ${outside.join(", ")}`
@@ -905,8 +953,19 @@ function rangesFor(m) {
 function rangesOverlap(a, b) {
   return a.base < b.base + b.count && b.base < a.base + a.count;
 }
+function ensureRanges(registry, m, repoRoot) {
+  const mine = rangesFor(m);
+  assertNoOverlap(registry, m, mine);
+  const current = registry.project(m.project);
+  if (current && JSON.stringify(current.ranges) === JSON.stringify(mine)) return;
+  registry.upsertProject(m.project, { root: repoRoot, ranges: mine });
+}
 function claimRanges(registry, m, repoRoot) {
   const mine = rangesFor(m);
+  assertNoOverlap(registry, m, mine);
+  registry.upsertProject(m.project, { root: repoRoot, ranges: mine });
+}
+function assertNoOverlap(registry, m, mine) {
   const others = Object.entries(registry.read().projects).filter(([name]) => name !== m.project);
   for (const [service, range] of Object.entries(mine)) {
     for (const [name, entry] of others) {
@@ -921,7 +980,6 @@ function claimRanges(registry, m, repoRoot) {
       }
     }
   }
-  registry.upsertProject(m.project, { root: repoRoot, ranges: mine });
 }
 
 // src/core/refresh.ts
@@ -1053,8 +1111,8 @@ import {
 } from "fs";
 var newId = (prefix) => `${prefix}_${randomBytes(4).toString("hex")}`;
 var EMPTY = { version: 1, projects: {}, leases: [], efforts: [] };
-var LOCK_STALE_MS = 3e4;
-var LOCK_WAIT_MS = 5e3;
+var LOCK_STALE_MS = 1e4;
+var LOCK_WAIT_MS = 15e3;
 function sleep(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
@@ -1110,7 +1168,9 @@ var Registry = class _Registry {
       } catch {
         try {
           if (Date.now() - statSync2(lock).mtimeMs > LOCK_STALE_MS) {
-            rmSync2(lock, { recursive: true, force: true });
+            const claimed = `${lock}.stale.${process.pid}.${Date.now()}`;
+            renameSync(lock, claimed);
+            rmSync2(claimed, { recursive: true, force: true });
             continue;
           }
         } catch {
@@ -1220,7 +1280,7 @@ var Registry = class _Registry {
       if (slot < 0) {
         throw new WorkkitError(
           "NO_FREE_SLOT",
-          `no free slot in ${project} (0..${m.slots.count - 1}, reserved ${[...reserved].join(",")})`
+          `no free slot in ${project} (0..${m.slots.count - 1}, reserved ${[...reserved].join(",")}): \`work status\` lists the efforts holding them; \`work finish\` or \`work reap\` frees one`
         );
       }
       const lease = this.lease(
@@ -1481,6 +1541,7 @@ export {
   currentOwner,
   emitWorktreeConfig,
   ensureExcluded,
+  ensureRanges,
   exitCodeFor,
   expandScopes,
   globsOverlap,