@maycombhq/atticus 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/{chunk-WVPJSRRJ.js → chunk-O4IKAIZ2.js}

@@ -11,31 +11,33 @@ import {
   changeLearn,
   changeList,
   changeNew,
+  changeReleasePrs,
   changeReturn,
   changeStatus,
   changeSync,
+  handoffPublisherFor,
   parseOwners
-} from "./chunk-T2UYZSCQ.js";
-import "./chunk-2VHF7OXM.js";
+} from "./chunk-COYN3UAN.js";
+import "./chunk-LQH4P45K.js";
+import "./chunk-BEPCKDCP.js";
+import "./chunk-HWD4JPU7.js";
+import "./chunk-5WERBKLE.js";
 import "./chunk-VOGCSYOI.js";
-import "./chunk-CKSITVS4.js";
-import "./chunk-L6SGQIR3.js";
-import "./chunk-3HI6Z55Y.js";
-import "./chunk-XY3P7JW7.js";
-import "./chunk-4AK7IBVP.js";
-import "./chunk-7JUKDRSZ.js";
-import "./chunk-27NKUS3X.js";
-import "./chunk-L24C55VN.js";
-import "./chunk-PAMPPUR6.js";
-import "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
-import "./chunk-MC3H7736.js";
-import "./chunk-T6AIP7H5.js";
-import "./chunk-EFHQ3TWP.js";
-import "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+import "./chunk-K332XW7K.js";
+import "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
+import "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import "./chunk-TV45EUGM.js";
 export {
   captureLine,
@@ -45,8 +47,10 @@ export {
   changeLearn,
   changeList,
   changeNew,
+  changeReleasePrs,
   changeReturn,
   changeStatus,
   changeSync,
+  handoffPublisherFor,
   parseOwners
 };

package/dist/{chunk-D3PO4DOZ.js → chunk-ODMBPDDV.js}

@@ -5,13 +5,13 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 
 // packages/core/dist/schema/version.js
-var SCHEMA_VERSION = 3;
+var SCHEMA_VERSION = 5;
 
 // packages/core/dist/fs.js
 import { randomBytes } from "node:crypto";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { hostname } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 async function writeFileAtomic(path, data) {
   await mkdir(dirname(path), { recursive: true });
   const tmp = `${path}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
@@ -23,6 +23,32 @@ async function writeFileAtomic(path, data) {
     throw e;
   }
 }
+var FileChangedError = class extends Error {
+  path;
+  constructor(path) {
+    super(`${path} changed since it was read (another edit, or a person's): nothing was written. Read it again and redo the change.`);
+    this.path = path;
+  }
+};
+var writing = /* @__PURE__ */ new Map();
+function writeFileIfUnchanged(path, before, data) {
+  const key = resolve(path);
+  const prev = writing.get(key) ?? Promise.resolve();
+  const work = async () => {
+    const now = await readFile(path, "utf8").catch(() => void 0);
+    if (now !== before)
+      throw new FileChangedError(path);
+    await writeFileAtomic(path, data);
+  };
+  const next = prev.then(work, work);
+  const tail = next.catch(() => void 0);
+  writing.set(key, tail);
+  void tail.then(() => {
+    if (writing.get(key) === tail)
+      writing.delete(key);
+  });
+  return next;
+}
 var BUSY = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
 async function renameRetrying(from, to, tries = 9) {
   for (let i = 0; ; i++) {
@@ -39,12 +65,15 @@ async function renameRetrying(from, to, tries = 9) {
 }
 var LockHeldError = class extends Error {
   held;
-  constructor(held) {
-    super(`Another ${held.what} is running (process ${held.pid} on ${held.host}, since ${held.startedAt}). Wait for it to finish.`);
+  file;
+  constructor(held, file) {
+    super(`Another ${held.what} is running (process ${held.pid} on ${held.host}, since ${held.startedAt}). Wait for it to finish${file ? `; if nothing is running, delete ${file}` : ""}.`);
     this.held = held;
+    this.file = file;
     this.name = "LockHeldError";
   }
 };
+var heldHere = /* @__PURE__ */ new Set();
 var lockFileOf = (root, name) => join(root, ".atticus", "locks", `${name}.json`);
 function alive(pid) {
   try {
@@ -54,16 +83,19 @@ function alive(pid) {
     return e.code === "EPERM";
   }
 }
-async function readLock(root, name) {
+async function readLock(root, name, o = {}) {
   try {
-    const info = JSON.parse(await readFile(lockFileOf(root, name), "utf8"));
-    const stale = info.host === hostname() ? !alive(info.pid) : false;
+    const file = lockFileOf(root, name);
+    const info = JSON.parse(await readFile(file, "utf8"));
+    const here = info.host === hostname();
+    const age = (o.now ?? (() => /* @__PURE__ */ new Date()))().getTime() - Date.parse(info.startedAt);
+    const stale = here && (!alive(info.pid) || info.pid === process.pid && !heldHere.has(file)) || o.maxAgeMs !== void 0 && Number.isFinite(age) && age > o.maxAgeMs;
     return { ...info, stale };
   } catch {
     return void 0;
   }
 }
-async function acquireLock(root, name, what, now = () => /* @__PURE__ */ new Date()) {
+async function acquireLock(root, name, what, now = () => /* @__PURE__ */ new Date(), o = {}) {
   const file = lockFileOf(root, name);
   await ensureLocalIgnore(root);
   await mkdir(dirname(file), { recursive: true });
@@ -77,18 +109,20 @@ async function acquireLock(root, name, what, now = () => /* @__PURE__ */ new Dat
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
       await writeFile(file, JSON.stringify(info), { encoding: "utf8", flag: "wx" });
+      heldHere.add(file);
       const release = async () => {
         const cur = await readLock(root, name);
         if (cur && cur.pid === info.pid && cur.startedAt === info.startedAt)
           await rm(file, { force: true });
+        heldHere.delete(file);
       };
       return interrupted ? { release, interrupted } : { release };
     } catch (e) {
       if (e.code !== "EEXIST")
         throw e;
-      const held = await readLock(root, name);
+      const held = await readLock(root, name, { ...o, now });
       if (held && !held.stale)
-        throw new LockHeldError(held);
+        throw new LockHeldError(held, file);
       if (held) {
         const { stale: _s, ...rest } = held;
         interrupted = rest;
@@ -105,7 +139,9 @@ var LOCAL_ONLY = [
   "backups/",
   "history/",
   "probe/",
-  "cache/"
+  "cache/",
+  // ADR 0161: where `atticus map --all` is in the estate, so running it again resumes.
+  "map-all/"
 ];
 async function ensureLocalIgnore(root) {
   const file = join(root, ".atticus", ".gitignore");
@@ -114,11 +150,10 @@ async function ensureLocalIgnore(root) {
   const missing = LOCAL_ONLY.filter((l) => !have.has(l));
   if (!missing.length)
     return;
-  await mkdir(dirname(file), { recursive: true });
   const prefix = text && !text.endsWith("\n") ? `${text}
 ` : text;
-  await writeFile(file, `${prefix}${prefix ? "" : "# This machine's own files: never committed.\n"}${missing.join("\n")}
-`, "utf8");
+  await writeFileAtomic(file, `${prefix}${prefix ? "" : "# This machine's own files: never committed.\n"}${missing.join("\n")}
+`);
 }
 
 // packages/core/dist/log.js
@@ -243,6 +278,8 @@ var NO_LOG = {
 export {
   SCHEMA_VERSION,
   writeFileAtomic,
+  FileChangedError,
+  writeFileIfUnchanged,
   renameRetrying,
   LockHeldError,
   lockFileOf,