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

package/dist/{chunk-JGZCG5VM.js → chunk-TNR75OXT.js}

@@ -5,27 +5,27 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   askHosts
-} from "./chunk-RVH5SUW5.js";
+} from "./chunk-MFR5OPBD.js";
 import {
   driftAfterScan
-} from "./chunk-OT2O76OS.js";
+} from "./chunk-UGUP3ZM6.js";
 import {
   diffCatalogs,
   diffIsEmpty,
   readCatalog,
   scanEstate,
   writeCatalog
-} from "./chunk-27NKUS3X.js";
+} from "./chunk-J2JAKCIW.js";
 import {
   loadRepos
-} from "./chunk-EFHQ3TWP.js";
+} from "./chunk-PKBHS4AA.js";
 import {
   catalogDirOf
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-Q2TECDIT.js";
 import {
   LockHeldError,
   acquireLock
-} from "./chunk-D3PO4DOZ.js";
+} from "./chunk-TUULXQRW.js";
 
 // packages/cli/dist/scan-commands.js
 import { join } from "node:path";
@@ -74,7 +74,7 @@ async function scanCommand(root, o, io) {
   }
   try {
     if (o.ref) {
-      const { scanBranch } = await import("./chunk-ZCJDOK2S.js");
+      const { scanBranch } = await import("./chunk-X4CXA2IL.js");
       return await scanBranch(root, o.ref, {
         ...o.repos ? { repos: o.repos } : {},
         ...o.full ? { full: true } : {},

package/dist/{chunk-D3PO4DOZ.js → chunk-TUULXQRW.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 { link, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { hostname } from "node:os";
-import { dirname, join } from "node:path";
+import { basename, 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;
@@ -98,6 +132,126 @@ async function acquireLock(root, name, what, now = () => /* @__PURE__ */ new Dat
   }
   throw new Error(`Couldn't take the ${name} lock at ${file}.`);
 }
+var sharedLockFileOf = (path) => `${path}.lock`;
+var sharing = /* @__PURE__ */ new Map();
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function withSharedFileLock(path, work, o = {}) {
+  const key = resolve(path);
+  const prev = sharing.get(key) ?? Promise.resolve();
+  const run = async () => {
+    const release = await takeSharedLock(key, o);
+    try {
+      return await work();
+    } finally {
+      await release();
+    }
+  };
+  const next = prev.then(run, run);
+  const tail = next.catch(() => void 0);
+  sharing.set(key, tail);
+  void tail.then(() => {
+    if (sharing.get(key) === tail)
+      sharing.delete(key);
+  });
+  return next;
+}
+async function takeSharedLock(path, o) {
+  const file = sharedLockFileOf(path);
+  const staleMs = o.staleMs ?? 1e4;
+  const waitMs = o.waitMs ?? 15e3;
+  const info = {
+    pid: process.pid,
+    host: hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    what: o.what ?? `write of ${basename(path)}`,
+    token: randomBytes(8).toString("hex")
+  };
+  await mkdir(dirname(file), { recursive: true });
+  const start = Date.now();
+  let delay = 5;
+  for (; ; ) {
+    let code;
+    try {
+      await writeFile(file, JSON.stringify(info), { encoding: "utf8", flag: "wx" });
+      return () => releaseShared(file, info.token);
+    } catch (e) {
+      code = e.code ?? "";
+      if (code !== "EEXIST" && !BUSY.has(code))
+        throw e;
+    }
+    let held;
+    if (code === "EEXIST") {
+      const seen = await readFile(file, "utf8").catch(() => void 0);
+      if (seen === void 0)
+        continue;
+      held = parseLockInfo(seen);
+      if (await isStaleShared(file, held, staleMs)) {
+        await takeOver(file, seen, info.token);
+        continue;
+      }
+    }
+    if (Date.now() - start > waitMs)
+      throw new LockHeldError(held ?? { pid: 0, host: "?", startedAt: "?", what: `write of ${basename(path)}` }, file);
+    await sleep(delay + Math.floor(Math.random() * delay));
+    delay = Math.min(delay * 2, 100);
+  }
+}
+function parseLockInfo(text) {
+  try {
+    const j = JSON.parse(text);
+    return typeof j.pid === "number" && typeof j.startedAt === "string" ? {
+      pid: j.pid,
+      host: String(j.host ?? ""),
+      startedAt: j.startedAt,
+      what: String(j.what ?? "")
+    } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function isStaleShared(file, held, staleMs) {
+  if (held && held.host === hostname() && held.pid !== process.pid && !alive(held.pid))
+    return true;
+  const since = held ? Date.parse(held.startedAt) : await stat(file).then((s) => s.mtimeMs, () => NaN);
+  return Number.isFinite(since) && Date.now() - since > staleMs;
+}
+async function takeOver(file, seen, token) {
+  const aside = `${file}.${token}.stale`;
+  try {
+    await rename(file, aside);
+  } catch {
+    return;
+  }
+  const moved = await readFile(aside, "utf8").catch(() => void 0);
+  if (moved !== void 0 && moved !== seen)
+    await link(aside, file).catch(() => void 0);
+  await rmRetrying(aside);
+}
+async function releaseShared(file, token) {
+  const now = await readFile(file, "utf8").catch(() => void 0);
+  if (now === void 0)
+    return;
+  try {
+    if (JSON.parse(now).token !== token)
+      return;
+  } catch {
+    return;
+  }
+  await rmRetrying(file);
+}
+async function rmRetrying(file, tries = 9) {
+  for (let i = 0; ; i++) {
+    try {
+      await rm(file, { force: true });
+      return;
+    } catch (e) {
+      const code = e.code ?? "";
+      if (!BUSY.has(code) || i >= tries - 1)
+        throw e;
+      await sleep(20 * 2 ** i);
+    }
+  }
+}
 var LOCAL_ONLY = [
   "me.yaml",
   "logs/",
@@ -105,7 +259,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 +270,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,11 +398,15 @@ var NO_LOG = {
 export {
   SCHEMA_VERSION,
   writeFileAtomic,
+  FileChangedError,
+  writeFileIfUnchanged,
   renameRetrying,
   LockHeldError,
   lockFileOf,
   readLock,
   acquireLock,
+  sharedLockFileOf,
+  withSharedFileLock,
   LOCAL_ONLY,
   ensureLocalIgnore,
   LOG_MAX_BYTES,