@n-seiji/nuthatch 0.1.5 → 0.2.1

package/dist/cli-wcnyhk4w.js

@@ -0,0 +1,124 @@
+import {
+  EXIT_SAFE_REJECTION,
+  fail
+} from "./cli-77yanq37.js";
+
+// src/infra/lock.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/domain/lock-policy.ts
+var canReclaimLock = (input) => {
+  if (input.processAlive !== false) {
+    return false;
+  }
+  return input.nowMs - input.startedAtMs > input.ttlMs;
+};
+
+// src/infra/lock.ts
+var LOCK_DIR_NAME = "nuthatch-lock";
+var LOCK_INFO_FILE = "info.json";
+var DEFAULT_TTL_MS = 30000;
+var HEARTBEAT_INTERVAL_MS = 5000;
+
+class LockHeldError extends Error {
+  info;
+  constructor(info) {
+    super(`Repository is locked by another nuthatch process (pid ${info.pid})`);
+    this.name = "LockHeldError";
+    this.info = info;
+  }
+}
+var isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const { code } = error;
+    if (code === "ESRCH") {
+      return false;
+    }
+    if (code === "EPERM") {
+      return true;
+    }
+    return "unknown";
+  }
+};
+var readLockInfo = async (lockDir) => {
+  try {
+    const raw = await readFile(join(lockDir, LOCK_INFO_FILE), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var writeLockInfo = async (lockDir, info) => {
+  await writeFile(join(lockDir, LOCK_INFO_FILE), JSON.stringify(info), "utf8");
+};
+var acquireRepoLock = async (commonDir, ttlMs = DEFAULT_TTL_MS) => {
+  const lockDir = join(commonDir, LOCK_DIR_NAME);
+  for (;; ) {
+    try {
+      await mkdir(lockDir);
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+      const existing = await readLockInfo(lockDir);
+      if (existing === null) {
+        throw new LockHeldError({ pid: -1, startedAtMs: 0, token: "unknown" });
+      }
+      const reclaimable = canReclaimLock({
+        processAlive: isProcessAlive(existing.pid),
+        startedAtMs: existing.startedAtMs,
+        nowMs: Date.now(),
+        ttlMs
+      });
+      if (!reclaimable) {
+        throw new LockHeldError(existing);
+      }
+      await rm(lockDir, { recursive: true, force: true });
+    }
+  }
+  const info = {
+    pid: process.pid,
+    startedAtMs: Date.now(),
+    token: randomUUID()
+  };
+  await writeLockInfo(lockDir, info);
+  const heartbeat = setInterval(() => {
+    writeLockInfo(lockDir, { ...info, startedAtMs: Date.now() });
+  }, HEARTBEAT_INTERVAL_MS);
+  heartbeat.unref();
+  return {
+    async release() {
+      clearInterval(heartbeat);
+      await rm(lockDir, { recursive: true, force: true });
+    }
+  };
+};
+var acquireUnlessHeld = async (commonDir) => {
+  try {
+    return await acquireRepoLock(commonDir);
+  } catch (error) {
+    if (error instanceof LockHeldError) {
+      return error;
+    }
+    throw error;
+  }
+};
+var withRepoLock = async (commonDir, mutate) => {
+  const lock = await acquireUnlessHeld(commonDir);
+  if (lock instanceof LockHeldError) {
+    return fail(EXIT_SAFE_REJECTION, lock.message);
+  }
+  try {
+    return await mutate();
+  } finally {
+    await lock.release();
+  }
+};
+
+export { withRepoLock };

package/dist/cli-y8vsqre6.js

@@ -0,0 +1,97 @@
+import {
+  parsePorcelain
+} from "./cli-b0tk5wcx.js";
+import {
+  EXIT_USAGE_ERROR,
+  fail,
+  pass,
+  reject
+} from "./cli-77yanq37.js";
+import {
+  isWithin,
+  classifyWorktreePath
+} from "./cli-a56b2ar0.js";
+
+// src/domain/branch-name.ts
+var isOptionLikeRef = (name) => name.startsWith("-");
+var optionLikeRefRejection = (label, name) => isOptionLikeRef(name) ? fail(EXIT_USAGE_ERROR, `Refusing ${label} "${name}": names starting with "-" would be parsed as git options.`) : null;
+var refArgumentRejection = (branch, track) => optionLikeRefRejection("branch", branch) ?? (track === undefined ? null : optionLikeRefRejection("--track ref", track));
+
+// src/infra/repo.ts
+import { basename, dirname, join } from "node:path";
+
+// src/domain/tracking.ts
+var resolveTrackingRef = (branch, remotes) => {
+  if (remotes.includes("origin")) {
+    return { kind: "track", ref: `origin/${branch}` };
+  }
+  const [first, second] = remotes;
+  if (first === undefined) {
+    return { kind: "none" };
+  }
+  if (second !== undefined) {
+    return { kind: "ambiguous" };
+  }
+  return { kind: "track", ref: `${first}/${branch}` };
+};
+
+// src/infra/repo.ts
+var loadRepoContext = async (git, fs, cwd) => {
+  const [commonDir, porcelainOut] = await Promise.all([
+    git.commonDir(cwd),
+    git.listWorktreesPorcelain(cwd)
+  ]);
+  const parsed = parsePorcelain(porcelainOut);
+  const [firstEntry] = parsed;
+  if (firstEntry === undefined) {
+    throw new Error("git worktree list returned no entries");
+  }
+  const rootPath = await realpathOrRaw(fs, firstEntry.path);
+  const managedRoot = join(dirname(rootPath), "_worktree", basename(rootPath));
+  const worktrees = await Promise.all(parsed.map(async (entry) => {
+    const resolvedPath = await realpathOrRaw(fs, entry.path);
+    return {
+      ...entry,
+      path: resolvedPath,
+      kind: classifyWorktreePath(resolvedPath, rootPath, managedRoot)
+    };
+  }));
+  return { rootPath, managedRoot, commonDir, worktrees };
+};
+var nestedWorktrees = (worktrees, path) => worktrees.filter((wt) => wt.path !== path && !wt.prunable && isWithin(path, wt.path));
+var isWorktreeDirty = (git, worktrees, path) => git.isDirty(path, nestedWorktrees(worktrees, path).map((wt) => wt.path));
+var worktreeDirtyState = async (git, fs, worktrees, wt) => {
+  if (wt.bare || wt.prunable || !await fs.exists(wt.path)) {
+    return null;
+  }
+  return isWorktreeDirty(git, worktrees, wt.path);
+};
+var resolveBranchCheckout = async (git, rootPath, branch, explicitTrack) => {
+  const localBranches = await git.listBranches(rootPath);
+  const createBranch = !localBranches.includes(branch);
+  let track = explicitTrack;
+  if (createBranch && track === undefined) {
+    const remotes = await git.remotesWithBranch(rootPath, branch);
+    const resolution = resolveTrackingRef(branch, remotes);
+    if (resolution.kind === "ambiguous") {
+      return reject(fail(EXIT_USAGE_ERROR, `Branch "${branch}" exists on multiple remotes (${remotes.join(", ")}). Use --track to disambiguate.`));
+    }
+    if (resolution.kind === "track") {
+      const rejection = optionLikeRefRejection("--track ref", resolution.ref);
+      if (rejection !== null) {
+        return reject(rejection);
+      }
+      track = resolution.ref;
+    }
+  }
+  return pass({ createBranch, ...track === undefined ? {} : { track } });
+};
+var realpathOrRaw = async (fs, path) => {
+  try {
+    return await fs.realpath(path);
+  } catch {
+    return path;
+  }
+};
+
+export { isOptionLikeRef, optionLikeRefRejection, refArgumentRejection, loadRepoContext, nestedWorktrees, isWorktreeDirty, worktreeDirtyState, resolveBranchCheckout };