@primitive.ai/prim 0.1.0-alpha.93 → 0.1.0-alpha.96

package/dist/{chunk-X64HTHUF.js → chunk-Y5W4TZM7.js}

@@ -1,13 +1,13 @@
 import {
   gitToplevel
-} from "./chunk-H4UNYFUC.js";
+} from "./chunk-DHOQGHKQ.js";
 import {
   atomicWriteFile,
   primConfigDirectory,
   syncDirectory,
   syncFile,
   withFileLockSync
-} from "./chunk-2GP5UFV7.js";
+} from "./chunk-DWRSEC34.js";
 
 // src/lib/bin-path.ts
 import { existsSync, readFileSync } from "fs";
@@ -127,6 +127,13 @@ function pinnedHookCommand(bin, args = "") {
 }
 var STABLE_HOOK_ARGUMENTS_RE = /^[-A-Za-z0-9_ ]*$/u;
 var STABLE_HOOK_BIN_RE = /^[A-Za-z0-9][A-Za-z0-9-]*$/u;
+var PRIM_CONFIG_SHELL_RESOLVER = [
+  'prim_absolute() { case "$1" in [/]* ) ;; *) return 1 ;; esac; case "$1" in [[:space:]]*|*[[:space:]]|*[/][/]*|*[/].[/]*|*[/]..[/]*|*[/].|*[/]..|?*[/]) return 1 ;; esac; }; ',
+  'prim_config=${PRIM_CONFIG_DIR:-}; if ! prim_absolute "$prim_config"; then prim_config=${XDG_CONFIG_HOME:-}; if prim_absolute "$prim_config"; then ',
+  'case "$prim_config" in /) prim_config=/prim ;; *) prim_config="$prim_config/prim" ;; esac; ',
+  'else prim_home=${HOME:-}; prim_absolute "$prim_home" || exit 78; case "$prim_home" in /) prim_config=/.config/prim ;; *) prim_config="$prim_home/.config/prim" ;; esac; ',
+  "fi; fi; "
+].join("");
 function stableHookCommand(bin, args = "") {
   if (!STABLE_HOOK_BIN_RE.test(bin) || !STABLE_HOOK_ARGUMENTS_RE.test(args)) {
     throw new Error("invalid stable hook command");
@@ -136,11 +143,7 @@ function stableHookCommand(bin, args = "") {
     // it as inert data during the rolling window so an older uninstall or
     // reinstall can remove the stable entry without invoking npm or PATH.
     `prim_legacy_reader='-p ${PKG_NAME}@stable prim-shim.sh ${bin} '; `,
-    'prim_absolute() { case "$1" in [/]* ) ;; *) return 1 ;; esac; case "$1" in [[:space:]]*|*[[:space:]]|*[/][/]*|*[/].[/]*|*[/]..[/]*|*[/].|*[/]..|?*[/]) return 1 ;; esac; }; ',
-    'prim_config=${PRIM_CONFIG_DIR:-}; if ! prim_absolute "$prim_config"; then prim_config=${XDG_CONFIG_HOME:-}; if prim_absolute "$prim_config"; then ',
-    'case "$prim_config" in /) prim_config=/prim ;; *) prim_config="$prim_config/prim" ;; esac; ',
-    'else prim_home=${HOME:-}; prim_absolute "$prim_home" || exit 78; case "$prim_home" in /) prim_config=/.config/prim ;; *) prim_config="$prim_home/.config/prim" ;; esac; ',
-    "fi; fi; ",
+    PRIM_CONFIG_SHELL_RESOLVER,
     `case "$prim_config" in /) prim_launcher=/${STABLE_HOOK_LAUNCHER_NAME} ;; *) prim_launcher="$prim_config/${STABLE_HOOK_LAUNCHER_NAME}" ;; esac; `,
     'exec "$prim_launcher" "$@"'
   ].join("");
@@ -220,6 +223,146 @@ import {
   writeFileSync
 } from "fs";
 import { delimiter, dirname as dirname2, isAbsolute as isAbsolute2, join as join2, resolve } from "path";
+
+// src/lib/git-hook-contract.ts
+var MANAGED_GIT_HOOK_NAMES = ["pre-commit", "post-commit", "post-rewrite"];
+var GIT_HOOK_ENTRYPOINT_NAME = "prim-git-hook-v1";
+var GIT_HOOK_CONTRACT_VERSION = 1;
+var CONTRACT_LINE_PREFIX = "# prim git hook v";
+var CONTRACT_LINE_RE = /^# prim git hook v([0-9]+)\b/mu;
+function blockMarkers(hook) {
+  return { start: `# >>> prim ${hook} hook >>>`, end: `# <<< prim ${hook} hook <<<` };
+}
+function entrypointCommand(hook) {
+  const script = [
+    PRIM_CONFIG_SHELL_RESOLVER,
+    `case "$prim_config" in /) prim_entry=/${GIT_HOOK_ENTRYPOINT_NAME} ;; `,
+    `*) prim_entry="$prim_config/${GIT_HOOK_ENTRYPOINT_NAME}" ;; esac; `,
+    '[ -x "$prim_entry" ] || exit 0; exec "$prim_entry" "$@"'
+  ].join("");
+  return `/bin/sh -c ${shellQuote(script)} ${GIT_HOOK_ENTRYPOINT_NAME} ${hook} "$@"`;
+}
+function managedHookBlock(hook) {
+  const { start, end } = blockMarkers(hook);
+  const header = `${CONTRACT_LINE_PREFIX}${GIT_HOOK_CONTRACT_VERSION}: a no-op unless prim is installed and enabled here (see \`prim hooks snippet ${hook}\`).`;
+  if (hook !== "post-rewrite") {
+    return `${start}
+${header}
+# shellcheck disable=SC2016
+${entrypointCommand(hook)} || :
+${end}`;
+  }
+  return `${start}
+${header}
+prim_rewrite_stdin=$(mktemp 2>/dev/null) || prim_rewrite_stdin=
+if test -n "\${prim_rewrite_stdin}" && cat >"\${prim_rewrite_stdin}"; then
+  # shellcheck disable=SC2016
+  ${entrypointCommand(hook)} <"\${prim_rewrite_stdin}" || :
+  exec <"\${prim_rewrite_stdin}"
+fi
+if test -n "\${prim_rewrite_stdin}"; then rm -f "\${prim_rewrite_stdin}"; fi
+unset prim_rewrite_stdin
+${end}`;
+}
+var OPEN_WORDS = /* @__PURE__ */ new Set(["then", "do", "else", "{", "(", "&&", "||", "|"]);
+function canonicalHookBlock(text) {
+  const tokens = [];
+  let word = "";
+  let quote;
+  const separate = () => {
+    const last = tokens.at(-1);
+    if (last !== void 0 && last !== ";" && !OPEN_WORDS.has(last)) tokens.push(";");
+  };
+  const flush = () => {
+    if (word === "") return;
+    const last = tokens.at(-1);
+    if (last !== void 0 && /^[0-9]*(?:<|>|>>|<&|>&)$/u.test(last))
+      tokens[tokens.length - 1] += word;
+    else tokens.push(word);
+    word = "";
+  };
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (quote) {
+      word += char;
+      if (char === quote) quote = void 0;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      word += char;
+    } else if (char === "#" && word === "") {
+      const end = text.indexOf("\n", index);
+      const comment = text.slice(index, end === -1 ? text.length : end);
+      tokens.push(comment.replace(/\s+/gu, " ").trim());
+      index = (end === -1 ? text.length : end) - 1;
+    } else if (char === "\n" || char === ";") {
+      flush();
+      if (char === ";" && text[index + 1] === ";") {
+        tokens.push(";;");
+        index += 1;
+      } else {
+        separate();
+      }
+    } else if (/\s/u.test(char)) {
+      flush();
+    } else {
+      word += char;
+    }
+  }
+  flush();
+  while (tokens.at(-1) === ";") tokens.pop();
+  return tokens.join("\0");
+}
+function hookBlockContractVersion(block) {
+  const match = CONTRACT_LINE_RE.exec(block);
+  return match?.[1] ? Number(match[1]) : void 0;
+}
+var GIT_HOOK_ENTRYPOINT_CONTENT = `#!/bin/sh
+# prim git hook entrypoint v1 \u2014 managed by prim; do not edit.
+# Run by the "# >>> prim <hook> hook >>>" block in a Git hook file. Acts only
+# where prim is active (git config prim.active true) and never fails the hook.
+case "$0" in */*) prim_dir=\${0%/*} ;; *) exit 0 ;; esac
+prim_launcher="$prim_dir/${STABLE_HOOK_LAUNCHER_NAME}"
+[ -x "$prim_launcher" ] || exit 0
+[ "$(git config --get prim.active 2>/dev/null)" = "true" ] || exit 0
+prim_hook=\${1-}
+if [ "$#" -gt 0 ]; then shift; fi
+case "$prim_hook" in
+pre-commit)
+  "$prim_launcher" prim-pre-commit "$@" || :
+  ;;
+post-commit)
+  prim_sha=$(git rev-parse --verify HEAD 2>/dev/null) || exit 0
+  case "$prim_sha" in *[!0-9a-f]* | "") exit 0 ;; esac
+  case "\${#prim_sha}" in 40 | 64) ;; *) exit 0 ;; esac
+  prim_branch=$(git symbolic-ref --quiet --short HEAD 2>/dev/null) || prim_branch=
+  prim_observed=$(mktemp "\${TMPDIR:-/tmp}/prim-post-commit-observed.XXXXXXXX" 2>/dev/null) || prim_observed=
+  (
+    trap '' HUP
+    trap 'if [ -n "$prim_observed" ]; then rm -f "$prim_observed"; fi' 0
+    PRIM_COMMIT_SHA=$prim_sha PRIM_COMMIT_BRANCH=$prim_branch PRIM_COMMIT_OBSERVED_FILE=$prim_observed "$prim_launcher" prim-post-commit
+  ) </dev/null >/dev/null 2>&1 &
+  ;;
+post-rewrite)
+  case "\${1-}" in amend | rebase) prim_source=$1 ;; *) exit 0 ;; esac
+  prim_pairs=$(mktemp "\${TMPDIR:-/tmp}/prim-post-rewrite-pairs.XXXXXXXX" 2>/dev/null) || exit 0
+  if ! chmod 600 "$prim_pairs" 2>/dev/null || ! cat >"$prim_pairs"; then
+    rm -f "$prim_pairs"
+    exit 0
+  fi
+  prim_branch=$(git symbolic-ref --quiet --short HEAD 2>/dev/null) || prim_branch=
+  (
+    trap '' HUP
+    trap 'rm -f "$prim_pairs"' 0
+    PRIM_REWRITE_SOURCE=$prim_source PRIM_REWRITE_BRANCH=$prim_branch PRIM_REWRITE_PAIRS_FILE=$prim_pairs "$prim_launcher" prim-post-rewrite
+  ) </dev/null >/dev/null 2>&1 &
+  ;;
+esac
+exit 0
+`;
+
+// src/lib/hook-runtime.ts
 var HOOK_RUNTIME_SCHEMA_VERSION = 1;
 var DIRECTORY_MODE = 448;
 var DATA_FILE_MODE = 384;
@@ -263,6 +406,7 @@ function hookRuntimePaths(options = {}) {
   return {
     configDir,
     launcher: join2(configDir, STABLE_HOOK_LAUNCHER_NAME),
+    gitHookEntrypoint: join2(configDir, GIT_HOOK_ENTRYPOINT_NAME),
     runtimeDir,
     releasesDir: join2(runtimeDir, "releases"),
     current: join2(runtimeDir, "current"),
@@ -636,6 +780,13 @@ function stageHookRuntime(options = {}) {
         mode: LAUNCHER_MODE
       });
     }
+    const entrypointCurrent = gitHookEntrypointCurrent(paths);
+    if (!entrypointCurrent) {
+      atomicWriteFile(paths.gitHookEntrypoint, GIT_HOOK_ENTRYPOINT_CONTENT, {
+        ensureParent: true,
+        mode: LAUNCHER_MODE
+      });
+    }
     if (!selectorCurrent) {
       syncDirectory(paths.releasesDir);
       atomicWriteFile(paths.current, `${finalRelease.name}
@@ -652,13 +803,38 @@ function stageHookRuntime(options = {}) {
       now
     );
     return {
-      changed: !launcherCurrent || !selectorCurrent,
+      changed: !launcherCurrent || !entrypointCurrent || !selectorCurrent,
       releaseDir: finalRelease.dir,
       manifest: finalRelease.manifest,
       paths
     };
   });
 }
+function gitHookEntrypointCurrent(paths) {
+  try {
+    return readFileSync2(paths.gitHookEntrypoint, "utf8") === GIT_HOOK_ENTRYPOINT_CONTENT;
+  } catch {
+    return false;
+  }
+}
+function inspectGitHookEntrypoint(options = {}) {
+  let paths;
+  try {
+    paths = hookRuntimePaths(options);
+  } catch {
+    return "invalid";
+  }
+  try {
+    const entrypoint = lstatIfPresent(paths.gitHookEntrypoint);
+    if (!entrypoint) return "missing";
+    if (!entrypoint.isFile() || (Number(entrypoint.mode) & 64) === 0 || !gitHookEntrypointCurrent(paths) || readFileSync2(paths.launcher, "utf8") !== STABLE_HOOK_LAUNCHER_CONTENT || !lstatIfPresent(paths.current)?.isFile()) {
+      return "invalid";
+    }
+    return "ready";
+  } catch {
+    return "invalid";
+  }
+}
 function lstatIfPresent(path) {
   try {
     return lstatSync(path);
@@ -669,6 +845,12 @@ function lstatIfPresent(path) {
   }
 }
 function assertOwnedHookRuntime(paths) {
+  const entrypoint = lstatIfPresent(paths.gitHookEntrypoint);
+  if (entrypoint && (!entrypoint.isFile() || !gitHookEntrypointCurrent(paths))) {
+    throw new Error(
+      `refusing to remove unrecognized Git hook entrypoint at ${paths.gitHookEntrypoint}`
+    );
+  }
   const launcher = lstatIfPresent(paths.launcher);
   if (launcher) {
     if (!launcher.isFile() || readFileSync2(paths.launcher, "utf8") !== STABLE_HOOK_LAUNCHER_CONTENT) {
@@ -708,15 +890,18 @@ function assertOwnedHookRuntime(paths) {
 function removeHookRuntime(options = {}) {
   const paths = hookRuntimePaths(options);
   const hadLauncher = lstatIfPresent(paths.launcher) !== void 0;
+  const hadEntrypoint = lstatIfPresent(paths.gitHookEntrypoint) !== void 0;
   const hadRuntime = lstatIfPresent(paths.runtimeDir) !== void 0;
-  if (!hadLauncher && !hadRuntime) return { changed: false, paths };
+  if (!hadLauncher && !hadEntrypoint && !hadRuntime) return { changed: false, paths };
   assertOwnedHookRuntime(paths);
   if (!hadRuntime) {
+    rmSync(paths.gitHookEntrypoint, { force: true });
     rmSync(paths.launcher, { force: true });
-    return { changed: hadLauncher, paths };
+    return { changed: true, paths };
   }
   withFileLockSync(paths.selectionLock, () => {
     assertOwnedHookRuntime(paths);
+    if (lstatIfPresent(paths.gitHookEntrypoint)) rmSync(paths.gitHookEntrypoint, { force: true });
     if (lstatIfPresent(paths.launcher)) rmSync(paths.launcher, { force: true });
     const quarantined = `${paths.runtimeDir}.uninstall-${String(process.pid)}-${randomBytes(8).toString("hex")}`;
     renameSync(paths.runtimeDir, quarantined);
@@ -1467,10 +1652,17 @@ export {
   stableHookCommand,
   commandMatchesBin,
   hookCommandResolutions,
+  MANAGED_GIT_HOOK_NAMES,
+  GIT_HOOK_CONTRACT_VERSION,
+  blockMarkers,
+  managedHookBlock,
+  canonicalHookBlock,
+  hookBlockContractVersion,
   hookRuntimePaths,
   inspectHookRuntime,
   stableNodePath,
   stageHookRuntime,
+  inspectGitHookEntrypoint,
   assertOwnedHookRuntime,
   removeHookRuntime,
   projectRoot,

package/dist/{chunk-ICM2XCXS.js → chunk-YYE2NLWX.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-EZXEWFDG.js";
 import {
   scrubEnvironmentPaths
-} from "./chunk-K7D2EYBS.js";
+} from "./chunk-URLLSALP.js";
 import {
   isValidRepoSyncId
-} from "./chunk-DSWT6BCC.js";
+} from "./chunk-DHOQGHKQ.js";
 
 // src/hooks/prim-hook-core.ts
 import { createHash, randomUUID } from "crypto";