@n-seiji/nuthatch 0.1.5 → 0.1.7

package/dist/cli-pqd2qe7v.js

@@ -0,0 +1,35 @@
+import {
+  REFS_HEADS_PREFIX
+} from "./cli-g72ra4e5.js";
+
+// src/domain/upstream.ts
+var NONE = { kind: "none" };
+var FIELD_SEPARATOR = "\x00";
+var UPSTREAM_FORMAT = "%(refname)%00%(upstream)%00%(upstream:track,nobracket)";
+var countOf = (track, word) => {
+  const match = new RegExp(`${word} (?<count>\\d+)`, "u").exec(track);
+  return match?.groups?.count === undefined ? 0 : Number(match.groups.count);
+};
+var parseTrack = (upstream, track) => {
+  if (upstream.length === 0) {
+    return NONE;
+  }
+  if (track === "gone") {
+    return { kind: "gone" };
+  }
+  return { kind: "tracking", ahead: countOf(track, "ahead"), behind: countOf(track, "behind") };
+};
+var parseUpstreamStates = (output) => {
+  const states = new Map;
+  for (const line of output.split(`
+`)) {
+    const [refname = "", upstream = "", track = ""] = line.split(FIELD_SEPARATOR);
+    if (refname.startsWith(REFS_HEADS_PREFIX)) {
+      states.set(refname.slice(REFS_HEADS_PREFIX.length), parseTrack(upstream, track.trim()));
+    }
+  }
+  return states;
+};
+var upstreamStateOf = (states, branch) => states.get(branch) ?? NONE;
+
+export { UPSTREAM_FORMAT, parseUpstreamStates, upstreamStateOf };

package/dist/cli-qrxgkskr.js

@@ -0,0 +1,69 @@
+import {
+  EXIT_GENERAL_ERROR,
+  EXIT_SAFE_REJECTION
+} from "./cli-2bhb9p0x.js";
+
+// src/domain/posix-path.ts
+var withoutTrailingSlash = (path) => path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+var parentDir = (path) => {
+  const trimmed = withoutTrailingSlash(path);
+  const index = trimmed.lastIndexOf("/");
+  if (index === -1) {
+    return ".";
+  }
+  return index === 0 ? "/" : trimmed.slice(0, index);
+};
+var baseName = (path) => {
+  const trimmed = withoutTrailingSlash(path);
+  return trimmed.slice(trimmed.lastIndexOf("/") + 1);
+};
+var absoluteCandidates = (dirs, name) => [
+  ...new Set(dirs.map((entry) => entry.trim()).filter((entry) => entry.startsWith("/")).map((dir) => `${dir.endsWith("/") ? dir.slice(0, -1) : dir}/${name}`))
+];
+var splitPathEnv = (pathEnv) => (pathEnv ?? "").split(":");
+
+// src/domain/git-executable.ts
+var GIT_EXECUTABLE_OVERRIDE_ENV = "HOP_GIT";
+var GIT_NOT_FOUND_ERROR_CODE = "HOP_GIT_NOT_FOUND";
+var GIT_NOT_FOUND_HINT = `Install git, or set ${GIT_EXECUTABLE_OVERRIDE_ENV} to its absolute path.`;
+var GIT_FALLBACK_BIN_DIRS = [
+  "/opt/homebrew/bin",
+  "/usr/local/bin",
+  "/usr/bin",
+  "/bin"
+];
+var gitExecutableCandidates = (input) => {
+  const override = input.override?.trim() ?? "";
+  if (override.length > 0) {
+    return [override];
+  }
+  return absoluteCandidates([...splitPathEnv(input.path), ...GIT_FALLBACK_BIN_DIRS], "git");
+};
+var gitNotFoundMessage = (candidates) => `git executable not found. Looked in: ${candidates.join(", ")}. ${GIT_NOT_FOUND_HINT}`;
+
+// src/domain/fatal-error.ts
+var fieldsOf = (error) => typeof error === "object" && error !== null ? error : {};
+var messageOf = (error) => error instanceof Error ? error.message : String(error);
+var trimmedStringOf = (value) => typeof value === "string" ? value.trim() : "";
+var isSpawnFailure = (fields) => fields.code === "ENOENT" && typeof fields.syscall === "string" && fields.syscall.startsWith("spawn");
+var isGitFailure = (fields) => typeof fields.code === "number" || typeof fields.signal === "string" && fields.signal !== "";
+var describeFatalError = (error) => {
+  const fields = fieldsOf(error);
+  if (isSpawnFailure(fields)) {
+    const binary = trimmedStringOf(fields.path) || "git";
+    return {
+      message: `failed to run ${binary}: no such executable. ${GIT_NOT_FOUND_HINT}`,
+      exitCode: EXIT_GENERAL_ERROR
+    };
+  }
+  if (isGitFailure(fields)) {
+    const stderr = trimmedStringOf(fields.stderr);
+    return {
+      message: stderr.length > 0 ? stderr : messageOf(error),
+      exitCode: EXIT_SAFE_REJECTION
+    };
+  }
+  return { message: messageOf(error), exitCode: EXIT_GENERAL_ERROR };
+};
+
+export { parentDir, baseName, absoluteCandidates, splitPathEnv, GIT_EXECUTABLE_OVERRIDE_ENV, GIT_NOT_FOUND_ERROR_CODE, gitExecutableCandidates, gitNotFoundMessage, messageOf, describeFatalError };

package/dist/cli-rcw5adqd.js

@@ -0,0 +1,124 @@
+import {
+  EXIT_SAFE_REJECTION,
+  fail
+} from "./cli-2bhb9p0x.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 };