@outerlayer/cli 0.1.0

package/dist/chunk-IWIUYLDR.js

@@ -0,0 +1,472 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import { existsSync, readFileSync, unlinkSync, readdirSync, mkdirSync, writeFileSync, chmodSync } from 'fs';
+import { join, isAbsolute, dirname, basename, resolve } from 'path';
+import { execFileSync } from 'child_process';
+
+createRequire(import.meta.url);
+var CONTEXT_EXCLUDE_MARKER = "outerlayer context materialization";
+var VERSION = 1;
+var CONTEXT_EXCLUDE_BEGIN_PREFIX = `# BEGIN ${CONTEXT_EXCLUDE_MARKER}`;
+var BEGIN_PREFIX = CONTEXT_EXCLUDE_BEGIN_PREFIX;
+var BEGIN = `${BEGIN_PREFIX} v${VERSION}`;
+var END = `# END ${CONTEXT_EXCLUDE_MARKER}`;
+var ENTRIES = ["/AGENTS.md", "/.claude/", "/.outerlayer/"];
+var BLOCK_LINES = [BEGIN, ...ENTRIES, END];
+function excludeFilePath(gitCommonDir) {
+  return join(gitCommonDir, "info", "exclude");
+}
+function readLines(path) {
+  if (!existsSync(path)) return [];
+  const content = readFileSync(path, "utf8");
+  if (content === "") return [];
+  const lines = content.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function writeLines(path, lines) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, lines.length ? lines.join("\n") + "\n" : "");
+}
+function findWellFormedBlock(lines) {
+  let i = 0;
+  while (i < lines.length) {
+    if (!lines[i].startsWith(BEGIN_PREFIX)) {
+      i++;
+      continue;
+    }
+    const beginIdx = i;
+    let endIdx = -1;
+    let j = beginIdx + 1;
+    for (; j < lines.length; j++) {
+      if (lines[j] === END) {
+        endIdx = j;
+        break;
+      }
+      if (lines[j].startsWith(BEGIN_PREFIX)) break;
+    }
+    if (endIdx !== -1) return { beginIdx, endIdx };
+    i = j;
+  }
+  return void 0;
+}
+function ensureContextExcludes(gitCommonDir) {
+  const path = excludeFilePath(gitCommonDir);
+  const lines = readLines(path);
+  const block = findWellFormedBlock(lines);
+  if (block !== void 0) {
+    const { beginIdx, endIdx } = block;
+    const current = lines.slice(beginIdx, endIdx + 1);
+    if (current.length === BLOCK_LINES.length && current.every((l, i) => l === BLOCK_LINES[i])) {
+      return { changed: false };
+    }
+    const next = [...lines.slice(0, beginIdx), ...BLOCK_LINES, ...lines.slice(endIdx + 1)];
+    writeLines(path, next);
+    return { changed: true };
+  }
+  writeLines(path, [...lines, ...BLOCK_LINES]);
+  return { changed: true };
+}
+function contextExcludesPresent(gitCommonDir) {
+  const lines = readLines(excludeFilePath(gitCommonDir));
+  const beginIdx = lines.findIndex((l) => l === BEGIN);
+  if (beginIdx === -1) return false;
+  return BLOCK_LINES.every((l, i) => lines[beginIdx + i] === l);
+}
+var POST_REWRITE_MARKER = "# outerlayer post-rewrite journal";
+var POST_REWRITE_VERSION = `${POST_REWRITE_MARKER} v1`;
+var POST_REWRITE_HOOK_SCRIPT = `#!/bin/sh
+${POST_REWRITE_VERSION}
+# Appends exact old->new commit pairs (amend/rebase, incl. squashes) to the
+# OuterLayer spool so rewritten history stays creditable to the recorded
+# sessions that produced it. Always exits 0: journaling must never break a
+# rebase.
+# On a machine without OuterLayer (this hook can be committed into a repo
+# and run for every contributor) there is nothing to journal and no reason
+# to create ~/.outerlayer: bow out before touching the filesystem.
+[ -n "$OUTERLAYER_SPOOL_DIR" ] || [ -d "$HOME/.outerlayer" ] || exit 0
+SPOOL_DIR="\${OUTERLAYER_SPOOL_DIR:-$HOME/.outerlayer/spool}"
+mkdir -p "$SPOOL_DIR" 2>/dev/null || exit 0
+FILE="$SPOOL_DIR/rewrites.jsonl"
+if [ -f "$FILE" ] && [ "$(wc -c < "$FILE" 2>/dev/null || echo 0)" -gt 5242880 ]; then
+  mv -f "$FILE" "$FILE.1" 2>/dev/null || true
+fi
+REPO="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)"
+if [ -z "$REPO" ]; then
+  REPO="$(git rev-parse --git-common-dir 2>/dev/null)" || exit 0
+  case "$REPO" in /*) ;; *) REPO="$PWD/$REPO" ;; esac
+fi
+TS="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+awk -v repo="$REPO" -v ts="$TS" -v src="$1" '
+  NF >= 2 && $1 ~ /^[0-9a-f]+$/ && $2 ~ /^[0-9a-f]+$/ {
+    pairs = pairs (n ? "," : "") "[\\"" $1 "\\",\\"" $2 "\\"]"; n++
+  }
+  END {
+    if (n) {
+      gsub(/\\\\/, "\\\\\\\\", repo); gsub(/"/, "\\\\\\"", repo)
+      printf "{\\"t\\":\\"%s\\",\\"repo\\":\\"%s\\",\\"source\\":\\"%s\\",\\"pairs\\":[%s]}\\n", ts, repo, src, pairs
+    }
+  }
+' >> "$FILE" 2>/dev/null || true
+exit 0
+`;
+var POST_COMMIT_HOOK_SCRIPT = `#!/bin/sh
+${POST_REWRITE_VERSION}
+# Appends every commit's SHA to the OuterLayer spool the moment it exists,
+# so a session whose transcript lost git's porcelain line (piped or muted
+# output) can still be credited at sync time. Always exits 0.
+# On a machine without OuterLayer (this hook can be committed into a repo
+# and run for every contributor) there is nothing to journal and no reason
+# to create ~/.outerlayer: bow out before touching the filesystem.
+[ -n "$OUTERLAYER_SPOOL_DIR" ] || [ -d "$HOME/.outerlayer" ] || exit 0
+SPOOL_DIR="\${OUTERLAYER_SPOOL_DIR:-$HOME/.outerlayer/spool}"
+mkdir -p "$SPOOL_DIR" 2>/dev/null || exit 0
+FILE="$SPOOL_DIR/commits.jsonl"
+if [ -f "$FILE" ] && [ "$(wc -c < "$FILE" 2>/dev/null || echo 0)" -gt 5242880 ]; then
+  mv -f "$FILE" "$FILE.1" 2>/dev/null || true
+fi
+REPO="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)"
+if [ -z "$REPO" ]; then
+  REPO="$(git rev-parse --git-common-dir 2>/dev/null)" || exit 0
+  case "$REPO" in /*) ;; *) REPO="$PWD/$REPO" ;; esac
+fi
+SHA="$(git rev-parse HEAD 2>/dev/null)" || exit 0
+TS="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+case "$SHA" in
+  *[!0-9a-f]*) exit 0 ;;
+esac
+REPO_ESCAPED=$(printf '%s' "$REPO" | sed -e 's/\\\\/\\\\\\\\/g' -e 's/"/\\\\"/g')
+printf '{"t":"%s","repo":"%s","sha":"%s"}
+' "$TS" "$REPO_ESCAPED" "$SHA" >> "$FILE" 2>/dev/null || true
+exit 0
+`;
+var PREPARE_COMMIT_MSG_HOOK_SCRIPT = `#!/bin/sh
+${POST_REWRITE_VERSION}
+# Appends "OuterLayer-Session: <id>" to commits made during a recorded agent
+# session, so the commit itself carries the session identity through squash
+# and cross-machine rebases (the server-side trailer tier parses it). Stamps
+# NOTHING outside a session: the agent env marker is required, and the id
+# comes from the shell's own session variable \u2014 exact, because the commit
+# process is a child of the session that issued it \u2014 with the spool journal
+# as the fallback for harnesses that don't export one. Always exits 0.
+# The journal-fallback selection rules mirror detectActiveSession in
+# packages/cli/src/session-detect.ts \u2014 keep them in step.
+[ -n "$OUTERLAYER_NO_TRAILER" ] && exit 0
+[ -n "$CLAUDECODE" ] || exit 0
+MSG_FILE="$1"
+[ -f "$MSG_FILE" ] || exit 0
+grep -qi '^outerlayer-session:' "$MSG_FILE" 2>/dev/null && exit 0
+SID="$CLAUDE_CODE_SESSION_ID"
+case "$SID" in
+  *[!0-9a-fA-F-]*) SID="" ;;
+esac
+if [ -n "$SID" ]; then
+  printf '\\nOuterLayer-Session: %s\\n' "$SID" >> "$MSG_FILE" 2>/dev/null || true
+  exit 0
+fi
+SPOOL_DIR="\${OUTERLAYER_SPOOL_DIR:-$HOME/.outerlayer/spool}"
+EVENTS="$SPOOL_DIR/events.jsonl"
+[ -f "$EVENTS" ] || exit 0
+TOP="$(git rev-parse --show-toplevel 2>/dev/null)" || exit 0
+[ -n "$TOP" ] || exit 0
+TOP_REAL="$(cd "$TOP" 2>/dev/null && pwd -P)" || TOP_REAL="$TOP"
+CUTOFF="$(date -u -v-24H +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -d '24 hours ago' +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || echo 1970-01-01T00:00:00Z)"
+SID="$(tail -c 65536 "$EVENTS" 2>/dev/null | awk -v top="$TOP" -v topr="$TOP_REAL" -v cutoff="$CUTOFF" '
+  function field(line, key,   re, v) {
+    re = "\\"" key "\\":\\"[^\\"]*\\""
+    if (match(line, re) == 0) return ""
+    v = substr(line, RSTART, RLENGTH)
+    sub("^\\"" key "\\":\\"", "", v); sub("\\"$", "", v)
+    return v
+  }
+  # macOS spells one directory two ways (/var is a symlink to /private/var);
+  # git reports the resolved form while the session recorded the launch
+  # spelling, so both sides normalize before comparing.
+  function norm(p) { sub(/^\\/private\\//, "/", p); return p }
+  function cwdMatches(c,   cn, tn, rn) {
+    cn = norm(c); tn = norm(top); rn = norm(topr)
+    return cn == tn || cn == rn || index(cn, tn "/") == 1 || index(cn, rn "/") == 1
+  }
+  /^\\{/ {
+    sid = field($0, "sessionId"); if (sid == "") next
+    ev = field($0, "event")
+    if (ev == "SessionEnd") { ended[sid] = 1; next }
+    t = field($0, "t"); c = field($0, "cwd")
+    if (t >= cutoff && cwdMatches(c)) { lastAt[sid] = NR }
+  }
+  END {
+    best = ""; bestNr = 0
+    for (sid in lastAt) if (!ended[sid] && lastAt[sid] > bestNr) { best = sid; bestNr = lastAt[sid] }
+    if (best != "" && best ~ /^[0-9a-fA-F-]+$/) print best
+  }
+')"
+[ -n "$SID" ] || exit 0
+printf '\\nOuterLayer-Session: %s\\n' "$SID" >> "$MSG_FILE" 2>/dev/null || true
+exit 0
+`;
+var PRE_COMMIT_GUARD_MARKER = "# outerlayer materialized-context commit guard";
+var PRE_COMMIT_GUARD_VERSION = `${PRE_COMMIT_GUARD_MARKER} v1`;
+var PRE_COMMIT_GUARD_BODY_SIGNATURE = "outerlayer: refusing to commit materialized control-plane context";
+var PRE_COMMIT_GUARD_SCRIPT = `#!/bin/sh
+${PRE_COMMIT_GUARD_VERSION}
+unset GIT_LITERAL_PATHSPECS GIT_GLOB_PATHSPECS GIT_NOGLOB_PATHSPECS GIT_ICASE_PATHSPECS
+PATH="$PATH:/usr/bin:/bin"
+export PATH
+COMMON_DIR="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)"
+if [ -z "$COMMON_DIR" ]; then
+  COMMON_DIR="$(git rev-parse --git-common-dir 2>/dev/null)" || exit 0
+  case "$COMMON_DIR" in /*) ;; *) COMMON_DIR="$PWD/$COMMON_DIR" ;; esac
+fi
+grep -qF "${CONTEXT_EXCLUDE_BEGIN_PREFIX}" "$COMMON_DIR/info/exclude" 2>/dev/null || exit 0
+
+if git rev-parse --verify -q HEAD >/dev/null 2>&1; then
+  BASE=HEAD
+  REMEDY="git restore --staged <path>"
+else
+  BASE="$(git hash-object -t tree --stdin < /dev/null)"
+  REMEDY="git rm --cached <path>"
+fi
+[ -n "$BASE" ] || exit 0
+
+BLOCKED="$(git diff --cached --name-only --diff-filter=A --no-renames --ignore-submodules=none "$BASE" -- ':(icase)AGENTS.md' ':(icase).claude' ':(icase).outerlayer' 2>/dev/null)"
+[ -n "$BLOCKED" ] || exit 0
+
+echo "${PRE_COMMIT_GUARD_BODY_SIGNATURE}:" >&2
+printf '%s\\n' "$BLOCKED" | while IFS= read -r path; do
+  [ -n "$path" ] && echo "  $path" >&2
+done
+echo "These paths come from a private control plane and must never enter this" >&2
+echo "repository's history. Unstage them to continue:" >&2
+echo "  $REMEDY" >&2
+exit 1
+`;
+function managedHookScripts() {
+  return [
+    ["post-rewrite", printableHookScript(POST_REWRITE_HOOK_SCRIPT)],
+    ["post-commit", printableHookScript(POST_COMMIT_HOOK_SCRIPT)],
+    ["prepare-commit-msg", printableHookScript(PREPARE_COMMIT_MSG_HOOK_SCRIPT)],
+    ["pre-commit", printableHookScript(PRE_COMMIT_GUARD_SCRIPT)]
+  ];
+}
+function printableHookScript(script) {
+  const lines = script.split("\n");
+  return [lines[0], ...lines.slice(2)].join("\n");
+}
+function git(cwd, args) {
+  try {
+    return execFileSync("git", ["-C", cwd, ...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function hooksDir(cwd) {
+  const dir = git(cwd, ["rev-parse", "--git-path", "hooks"]);
+  if (dir === void 0) return void 0;
+  return isAbsolute(dir) ? dir : resolve(cwd, dir);
+}
+function commonHooksDir(cwd) {
+  const abs = git(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (abs !== void 0) return join(abs, "hooks");
+  const rel = git(cwd, ["rev-parse", "--git-common-dir"]);
+  if (rel === void 0) return void 0;
+  return join(isAbsolute(rel) ? rel : join(cwd, rel), "hooks");
+}
+function installHookFile(dir, name, script, marker) {
+  const path = join(dir, name);
+  let existing;
+  try {
+    existing = readFileSync(path, "utf8");
+  } catch {
+    existing = void 0;
+  }
+  if (existing !== void 0) {
+    if (!isOwnRecognitionLine(existing, marker)) return "skipped-foreign";
+    if (existing === script) {
+      try {
+        chmodSync(path, 493);
+      } catch {
+      }
+      return "unchanged";
+    }
+  }
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path, script);
+  chmodSync(path, 493);
+  return existing === void 0 ? "installed" : "updated";
+}
+function installPostRewriteHook(cwd, opts) {
+  const stampTrailers = opts?.stampTrailers ?? true;
+  const inRepo = git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (inRepo !== "true") return { status: "not-a-repo" };
+  if ((git(cwd, ["config", "core.hooksPath"]) ?? "") !== "") {
+    return { status: "skipped-custom-hooks-path" };
+  }
+  const dir = hooksDir(cwd);
+  if (dir === void 0) return { status: "not-a-repo" };
+  const pairOutcomes = [
+    installHookFile(dir, "post-rewrite", POST_REWRITE_HOOK_SCRIPT, POST_REWRITE_MARKER),
+    installHookFile(dir, "post-commit", POST_COMMIT_HOOK_SCRIPT, POST_REWRITE_MARKER)
+  ];
+  const outcomes = [...pairOutcomes];
+  if (stampTrailers) {
+    outcomes.push(installHookFile(dir, "prepare-commit-msg", PREPARE_COMMIT_MSG_HOOK_SCRIPT, POST_REWRITE_MARKER));
+  } else {
+    removeOurHookFile(join(dir, "prepare-commit-msg"), POST_REWRITE_MARKER);
+  }
+  const path = join(dir, "post-rewrite");
+  if (pairOutcomes.every((o) => o === "skipped-foreign")) return { status: "skipped-foreign", path };
+  if (outcomes.every((o) => o === "unchanged")) return { status: "unchanged", path };
+  if (outcomes.includes("updated")) return { status: "updated", path };
+  if (outcomes.includes("installed")) return { status: "installed", path };
+  return { status: "skipped-foreign", path };
+}
+function removeOurHookFile(path, marker) {
+  if (!existsSync(path)) return false;
+  let content;
+  try {
+    content = readFileSync(path, "utf8");
+  } catch {
+    return false;
+  }
+  if (!isOwnRecognitionLine(content, marker)) return false;
+  unlinkSync(path);
+  return true;
+}
+function isOwnRecognitionLine(content, marker) {
+  const secondLine = content.split("\n", 2)[1];
+  return secondLine !== void 0 && secondLine.startsWith(marker);
+}
+function removePostRewriteHook(cwd) {
+  const dir = hooksDir(cwd);
+  if (dir === void 0) return { removed: false };
+  let removed = false;
+  for (const name of ["post-rewrite", "post-commit", "prepare-commit-msg"]) {
+    if (removeOurHookFile(join(dir, name), POST_REWRITE_MARKER)) removed = true;
+  }
+  return { removed, path: join(dir, "post-rewrite") };
+}
+function postRewriteHookPresence(cwd) {
+  const inRepo = git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (inRepo !== "true") return "not-a-repo";
+  if ((git(cwd, ["config", "core.hooksPath"]) ?? "") !== "") return "custom-hooks-path";
+  const dir = hooksDir(cwd);
+  if (dir === void 0) return "not-a-repo";
+  const states = ["post-rewrite", "post-commit"].map((name) => {
+    let content;
+    try {
+      content = readFileSync(join(dir, name), "utf8");
+    } catch {
+      return "absent";
+    }
+    return content.includes(POST_REWRITE_MARKER) ? "ours" : "foreign";
+  });
+  if (states.every((st) => st === "ours")) return "ours";
+  if (states.includes("foreign")) return "foreign";
+  return "absent";
+}
+function installPreCommitGuardHook(cwd) {
+  const inRepo = git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (inRepo !== "true") return { status: "not-a-repo", adopted: false };
+  const hooksPath = git(cwd, ["config", "core.hooksPath"]) ?? "";
+  if (hooksPath !== "") {
+    const expanded = expandHooksPathTilde(hooksPath);
+    const effectiveDir = isAbsolute(expanded) ? expanded : join(git(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd, expanded);
+    const path2 = join(effectiveDir, "pre-commit");
+    return { status: "skipped-custom-hooks-path", path: path2, adopted: guardAdoptedAtEffectiveHook(path2) };
+  }
+  const dir = hooksDir(cwd);
+  if (dir === void 0) return { status: "not-a-repo", adopted: false };
+  const path = join(dir, "pre-commit");
+  const status = installHookFile(dir, "pre-commit", PRE_COMMIT_GUARD_SCRIPT, PRE_COMMIT_GUARD_MARKER);
+  return { status, path, adopted: status === "skipped-foreign" ? guardBodyPresent(path) : true };
+}
+function removePreCommitGuardHook(cwd) {
+  const dir = commonHooksDir(cwd);
+  if (dir === void 0) return { removed: false };
+  const path = join(dir, "pre-commit");
+  return { removed: removeOurHookFile(path, PRE_COMMIT_GUARD_MARKER), path };
+}
+var GUARD_BODY_LINE_PREFIXES = [`echo "${PRE_COMMIT_GUARD_BODY_SIGNATURE}`, `echo '${PRE_COMMIT_GUARD_BODY_SIGNATURE}`];
+function guardBodyPresent(path) {
+  let content;
+  try {
+    content = readFileSync(path, "utf8");
+  } catch {
+    return false;
+  }
+  return content.split("\n").some((line) => {
+    const trimmed = line.trimStart();
+    return GUARD_BODY_LINE_PREFIXES.some((prefix) => trimmed.startsWith(prefix));
+  });
+}
+function guardAdoptedAtEffectiveHook(effectiveHookPath) {
+  if (guardBodyPresent(effectiveHookPath)) return true;
+  const shimDir = dirname(effectiveHookPath);
+  if (basename(shimDir) !== "_") return false;
+  return guardBodyPresent(join(dirname(shimDir), basename(effectiveHookPath)));
+}
+function expandHooksPathTilde(hooksPath) {
+  if (hooksPath === "~") return homeFromEnv();
+  if (hooksPath.startsWith("~/")) return join(homeFromEnv(), hooksPath.slice(2));
+  return hooksPath;
+}
+function ensurePreCommitGuardHook(repoRoot, gitCommonDir) {
+  const hooksPath = git(repoRoot, ["config", "core.hooksPath"]) ?? "";
+  if (hooksPath !== "") {
+    const expanded = expandHooksPathTilde(hooksPath);
+    const effectivePath = isAbsolute(expanded) ? join(expanded, "pre-commit") : join(repoRoot, expanded, "pre-commit");
+    return { status: "skipped-custom-hooks-path", adopted: guardAdoptedAtEffectiveHook(effectivePath) };
+  }
+  const path = join(gitCommonDir, "hooks", "pre-commit");
+  const status = installHookFile(join(gitCommonDir, "hooks"), "pre-commit", PRE_COMMIT_GUARD_SCRIPT, PRE_COMMIT_GUARD_MARKER);
+  return { status, adopted: status === "skipped-foreign" ? guardBodyPresent(path) : true };
+}
+function deadHooksState(cwd) {
+  const inRepo = git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (inRepo !== "true") return { dead: false };
+  const hooksPath = git(cwd, ["config", "core.hooksPath"]) ?? "";
+  if (hooksPath === "") return { dead: false };
+  const top = git(cwd, ["rev-parse", "--show-toplevel"]);
+  if (top === void 0) return { dead: false };
+  const expanded = expandHooksPathTilde(hooksPath);
+  const hooksDir2 = isAbsolute(expanded) ? expanded : join(top, expanded);
+  let entries;
+  try {
+    entries = readdirSync(hooksDir2);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return { dead: true, hooksDir: hooksDir2, repoRoot: top };
+    return { dead: false, hooksDir: hooksDir2, repoRoot: top, unreadableError: err };
+  }
+  const dead = entries.filter((e) => e !== ".gitignore").length === 0;
+  return { dead, hooksDir: hooksDir2, repoRoot: top };
+}
+var ALLOWED_PACKAGE_MANAGERS = ["yarn", "npm", "pnpm", "bun"];
+function preparePackageManagerCommand(repoRoot) {
+  let declared = "";
+  try {
+    const pkg = JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf8"));
+    if (typeof pkg.packageManager === "string") declared = pkg.packageManager.split("@")[0] ?? "";
+  } catch {
+    declared = "";
+  }
+  if (!ALLOWED_PACKAGE_MANAGERS.includes(declared)) declared = "";
+  if (declared === "yarn") return "yarn prepare";
+  return `${declared || "npm"} run prepare`;
+}
+function huskyPrepareScript(repoRoot) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf8"));
+    const script = pkg.scripts?.prepare;
+    if (typeof script === "string" && /husky/i.test(script)) return script;
+  } catch {
+  }
+  return null;
+}
+
+export { contextExcludesPresent, deadHooksState, ensureContextExcludes, ensurePreCommitGuardHook, huskyPrepareScript, installPostRewriteHook, installPreCommitGuardHook, managedHookScripts, postRewriteHookPresence, preparePackageManagerCommand, removePostRewriteHook, removePreCommitGuardHook };

package/dist/chunk-JJP7YLMN.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+var RUNNER_DIR_MODE = 448;
+var RUNNER_FILE_MODE = 384;
+function runnerDir(configPath) {
+  return join(dirname(configPath), "runner");
+}
+function pidFilePath(configPath) {
+  return join(runnerDir(configPath), "runner.pid");
+}
+function jobsDir(configPath) {
+  return join(runnerDir(configPath), "jobs");
+}
+function jobDir(configPath, queue, item, claimId, attempt) {
+  const suffix = attempt === void 0 ? "" : `-${attempt}`;
+  return join(jobsDir(configPath), `${queue}-${item}-${claimId}${suffix}`);
+}
+function attemptStamp(at) {
+  return at.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+
+export { RUNNER_DIR_MODE, RUNNER_FILE_MODE, attemptStamp, jobDir, jobsDir, pidFilePath, runnerDir };