@primitive.ai/prim 0.1.0-alpha.64 → 0.1.0-alpha.66

package/dist/index.js

@@ -1,4 +1,23 @@
 #!/usr/bin/env node
+import {
+  bindRepository,
+  compareSemver,
+  ensureEffectivePostCommitHook,
+  ensureEffectivePostRewriteHook,
+  ensurePostCommitHookAtPath,
+  ensurePostRewriteHookAtPath,
+  inspectEffectivePostCommitHook,
+  inspectEffectivePostRewriteHook,
+  postCommitHookBlock,
+  postRewriteHookBlock,
+  printJson,
+  registerSkillCommands,
+  resolveRepositoryBinding,
+  uninstallPostCommitHookAtPath,
+  uninstallPostRewriteHookAtPath,
+  uninstallProjectPostCommitHook,
+  uninstallProjectPostRewriteHook
+} from "./chunk-DR66XM5L.js";
 import {
   bold,
   boundedHealthError,
@@ -14,6 +33,9 @@ import {
   daemonOrDirectGet,
   formatDecisionsWarning
 } from "./chunk-WS3MCNFD.js";
+import {
+  fetchFeedbackCapability
+} from "./chunk-KHZNYEUV.js";
 import {
   JOURNAL_DIR,
   SESSIONS_DIR,
@@ -23,22 +45,6 @@ import {
   pendingJournalStats,
   readMovesFromPath
 } from "./chunk-HIMWM526.js";
-import {
-  bindRepository,
-  compareSemver,
-  ensureEffectivePostCommitHook,
-  ensurePostCommitHookAtPath,
-  inspectEffectivePostCommitHook,
-  postCommitHookBlock,
-  printJson,
-  registerSkillCommands,
-  resolveRepositoryBinding,
-  uninstallPostCommitHookAtPath,
-  uninstallProjectPostCommitHook
-} from "./chunk-MCPHIB4W.js";
-import {
-  fetchFeedbackCapability
-} from "./chunk-KHZNYEUV.js";
 import {
   inspectWorkspaceId
 } from "./chunk-UVIWZWM6.js";
@@ -49,7 +55,7 @@ import {
   packageVersion,
   pinnedHookCommand,
   warmBinCache
-} from "./chunk-LNU44OJV.js";
+} from "./chunk-CZ24W5QU.js";
 import {
   canonicalGitRoot,
   canonicalRepositoryPath,
@@ -59,7 +65,7 @@ import {
   isValidRepoSyncId,
   repoSyncId,
   setRepoActive
-} from "./chunk-XTNMSS4C.js";
+} from "./chunk-TDRXHBEX.js";
 import {
   HttpError,
   REFRESH_TOKEN_PATH,
@@ -97,22 +103,57 @@ async function applyActivation(active) {
     );
     process.exit(1);
   }
+  let phase = active ? "post-commit hook coverage" : "local deactivation";
   try {
-    let bound;
+    let binding;
     let postCommitHook;
+    let postRewriteHook;
     if (active) {
       postCommitHook = ensureEffectivePostCommitHook(root).path;
-      bound = await bindRepository(root);
+      try {
+        postRewriteHook = ensureEffectivePostRewriteHook(root).path;
+      } catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`[prim] post-rewrite hook coverage is degraded: ${detail}
+`);
+      }
+      phase = "repository binding";
+      binding = await bindRepository(root);
+      phase = "local activation";
     }
     setRepoActive(root, active);
     await daemonRequest("statusline_invalidate", {}, { timeoutMs: 250 });
-    process.stderr.write(`[prim] prim ${active ? "enabled" : "disabled"} in ${root}
+    if (binding?.status === "pending") {
+      process.stderr.write(`[prim] Prim is enabled locally in ${root}
+`);
+      process.stderr.write(
+        `[prim] repository ${binding.repositoryFullName} is not connected to Primitive; Moves still ingest into the team graph without repository-specific file attribution, Conflict Gate verification, or commit correlation
+`
+      );
+      process.stderr.write(
+        `[prim] ask an organization owner or administrator to grant Primitive's GitHub App access to this repository through Primitive's GitHub App onboarding; binding retries automatically at the next agent SessionStart
+`
+      );
+    } else {
+      process.stderr.write(`[prim] prim ${active ? "enabled" : "disabled"} in ${root}
 `);
-    printJson({ active, repo: root, ...bound, ...postCommitHook ? { postCommitHook } : {} });
+    }
+    printJson({
+      active,
+      repo: root,
+      ...binding ? {
+        bindingStatus: binding.status,
+        repositoryFullName: binding.repositoryFullName,
+        ...binding.status === "connected" ? { repoSyncId: binding.repoSyncId } : {}
+      } : {},
+      ...postCommitHook ? { postCommitHook } : {},
+      ...postRewriteHook ? { postRewriteHook } : {}
+    });
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
     process.stderr.write(
-      `[prim] failed to ${active ? "cover, bind, and enable" : "disable"} prim: ${detail}
+      active ? `[prim] failed to enable prim during ${phase}: ${detail}
+` : `[prim] failed to disable prim: ${detail}
 `
     );
     process.exit(1);
@@ -3917,7 +3958,28 @@ function checkWorkspaceIdentity() {
       };
   }
 }
-function classifyRepositoryBinding(value, currentServerValue) {
+function classifyRepositoryBinding(value, current, active) {
+  if (current.status === "pending") {
+    if (value !== void 0) {
+      return {
+        name: "repo-binding",
+        status: "fail",
+        detail: `local repository binding is stale for ${current.repositoryFullName} \u2014 run \`prim enable\``
+      };
+    }
+    if (!active) {
+      return {
+        name: "repo-binding",
+        status: "fail",
+        detail: "passive capture is inactive \u2014 run `prim enable`"
+      };
+    }
+    return {
+      name: "repo-binding",
+      status: "warn",
+      detail: `${current.repositoryFullName} is not connected to Primitive \u2014 local capture is active, but file scoping, Conflict Gate verification, and commit correlation are unavailable; ask an organization owner/admin to grant the Primitive GitHub App access (retried automatically next SessionStart)`
+    };
+  }
   if (!isValidRepoSyncId(value)) {
     return {
       name: "repo-binding",
@@ -3925,7 +3987,7 @@ function classifyRepositoryBinding(value, currentServerValue) {
       detail: "missing or invalid local prim.repoSyncId \u2014 run `prim enable`"
     };
   }
-  if (currentServerValue !== void 0 && value !== currentServerValue) {
+  if (value !== current.repoSyncId) {
     return {
       name: "repo-binding",
       status: "fail",
@@ -3935,50 +3997,49 @@ function classifyRepositoryBinding(value, currentServerValue) {
   return {
     name: "repo-binding",
     status: "ok",
-    detail: currentServerValue === void 0 ? "valid local repository binding ready" : "local repository binding matches the current server binding"
+    detail: "local repository binding matches the current server binding"
   };
 }
 async function checkRepositoryBinding() {
   const root = process.cwd();
   const local = repoSyncId(root);
-  const localCheck = classifyRepositoryBinding(local);
-  if (localCheck.status === "fail") return localCheck;
   try {
     const current = await resolveRepositoryBinding(root, {
       signal: AbortSignal.timeout(CONNECTIVITY_TIMEOUT_MS),
       quietRefresh: true
     });
-    return classifyRepositoryBinding(local, current.repoSyncId);
+    return classifyRepositoryBinding(local, current, isRepoActiveForCapture(root));
   } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
+    const message = error instanceof Error ? error.message : String(error);
+    const detail = boundedHealthError(`could not verify the current repository binding \u2014 ${message}`) ?? "could not verify the current repository binding";
     return {
       name: "repo-binding",
       status: "fail",
-      detail: `could not verify the current repository binding \u2014 ${detail.slice(0, 80)}`
+      detail
     };
   }
 }
-function classifyPostCommitHook(inspection) {
+function classifyManagedHook(hookName, inspection) {
   if (inspection.covered) {
     return {
-      name: "post-commit",
+      name: hookName,
       status: "ok",
       detail: `effective and executable \xB7 ${inspection.kind} \xB7 ${inspection.hookPath}`
     };
   }
   return {
-    name: "post-commit",
+    name: hookName,
     status: "fail",
     detail: `${inspection.reason ?? "uncovered"} \xB7 ${inspection.hookPath}`
   };
 }
-function checkPostCommitHook() {
+function checkManagedHook(hookName, inspect) {
   try {
-    return classifyPostCommitHook(inspectEffectivePostCommitHook());
+    return classifyManagedHook(hookName, inspect());
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     return {
-      name: "post-commit",
+      name: hookName,
       status: /not a git repository/iu.test(detail) ? "warn" : "fail",
       detail: detail.slice(0, 120)
     };
@@ -4104,7 +4165,8 @@ async function collectChecks() {
     checkFeedbackHooks(),
     checkWorkspaceIdentity(),
     await checkRepositoryBinding(),
-    checkPostCommitHook(),
+    checkManagedHook("post-commit", inspectEffectivePostCommitHook),
+    checkManagedHook("post-rewrite", inspectEffectivePostRewriteHook),
     ...backend,
     await checkFeedbackCapability()
   ];
@@ -4488,7 +4550,8 @@ import { dirname as dirname4, join as join7, resolve as resolve2 } from "path";
 import { Option as Option3 } from "commander";
 var PRE_COMMIT = { hookName: "pre-commit", binName: "prim-pre-commit" };
 var POST_COMMIT = { hookName: "post-commit", binName: "prim-post-commit" };
-var HOOKS = [PRE_COMMIT, POST_COMMIT];
+var POST_REWRITE = { hookName: "post-rewrite", binName: "prim-post-rewrite" };
+var HOOKS = [PRE_COMMIT, POST_COMMIT, POST_REWRITE];
 var GIT_TIMEOUT_MS = 1e3;
 function blockMarkers(spec) {
   return {
@@ -4517,6 +4580,7 @@ ${hookShim(spec.binName)}
 }
 function huskyBlock(spec) {
   if (spec.hookName === POST_COMMIT.hookName) return postCommitHookBlock();
+  if (spec.hookName === POST_REWRITE.hookName) return postRewriteHookBlock();
   const { start, end } = blockMarkers(spec);
   return `${start}
 ${hookShim(spec.binName)}
@@ -4524,6 +4588,7 @@ ${end}`;
 }
 function gatedBlock(spec) {
   if (spec.hookName === POST_COMMIT.hookName) return postCommitHookBlock();
+  if (spec.hookName === POST_REWRITE.hookName) return postRewriteHookBlock();
   const { start, end } = blockMarkers(spec);
   return `${start}
 ${gatedShim(spec.binName)}
@@ -4661,7 +4726,6 @@ var PASSTHROUGH_HOOKS = [
   "post-checkout",
   "post-merge",
   "pre-push",
-  "post-rewrite",
   "pre-auto-gc",
   "push-to-checkout",
   "sendemail-validate",
@@ -4671,11 +4735,13 @@ var PASSTHROUGH_HOOKS = [
   //  with a query protocol, not a lifecycle event, so a bare exec stub is wrong.)
 ];
 function globalHookScript(spec) {
-  const chainExit = spec.hookName === "pre-commit" ? "|| exit $?" : "|| true";
-  const invocation = spec.hookName === POST_COMMIT.hookName ? postCommitHookBlock() : gatedShim(spec.binName);
-  const beforeComments = spec.hookName === POST_COMMIT.hookName ? `${invocation}
+  const chainExit = spec.hookName === PRE_COMMIT.hookName ? "|| exit $?" : "|| true";
+  const managedBlock = spec.hookName === POST_COMMIT.hookName ? postCommitHookBlock() : spec.hookName === POST_REWRITE.hookName ? postRewriteHookBlock() : void 0;
+  const invocation = managedBlock ?? gatedShim(spec.binName);
+  const managedRepoGuard = managedBlock ? ` && ! grep -Fq '${blockMarkers(spec).start}' "$repo_hook" 2>/dev/null` : "";
+  const beforeComments = managedBlock ? `${invocation}
 ` : "";
-  const afterComments = spec.hookName === POST_COMMIT.hookName ? "" : `${invocation}
+  const afterComments = managedBlock ? "" : `${invocation}
 `;
   return `#!/bin/sh
 ${beforeComments}# prim global ${spec.hookName} hook (core.hooksPath) \u2014 managed by prim; do not edit.
@@ -4685,7 +4751,7 @@ ${beforeComments}# prim global ${spec.hookName} hook (core.hooksPath) \u2014 man
 # hook regardless, so inactive repos are unaffected.
 ${afterComments}common_dir=$(git rev-parse --git-common-dir 2>/dev/null) || exit 0
 repo_hook="$common_dir/hooks/${spec.hookName}"
-if [ -x "$repo_hook" ] && ! grep -q '${PRIM_MANAGED_MARK}' "$repo_hook" 2>/dev/null; then
+if [ -x "$repo_hook" ] && ! grep -q '${PRIM_MANAGED_MARK}' "$repo_hook" 2>/dev/null${managedRepoGuard}; then
   "$repo_hook" "$@" ${chainExit}
 fi
 exit 0
@@ -4711,6 +4777,8 @@ function writeOwnHooks() {
     const path = resolve2(PRIM_GIT_HOOKS_DIR, spec.hookName);
     if (spec.hookName === POST_COMMIT.hookName) {
       ensurePostCommitHookAtPath(path, globalHookScript(spec));
+    } else if (spec.hookName === POST_REWRITE.hookName) {
+      writeFileSync4(path, globalHookScript(spec), { mode: 493 });
     } else {
       writeFileSync4(path, globalHookScript(spec), { mode: 493 });
     }
@@ -4724,6 +4792,10 @@ function appendPrimBlock(hookPath, spec) {
     ensurePostCommitHookAtPath(hookPath);
     return;
   }
+  if (spec.hookName === POST_REWRITE.hookName) {
+    ensurePostRewriteHookAtPath(hookPath);
+    return;
+  }
   mergePrimBlock(hookPath, gatedBlock(spec), spec.binName);
 }
 function stripPrimBlock(hookPath, spec) {
@@ -4731,6 +4803,10 @@ function stripPrimBlock(hookPath, spec) {
     uninstallPostCommitHookAtPath(hookPath);
     return;
   }
+  if (spec.hookName === POST_REWRITE.hookName) {
+    uninstallPostRewriteHookAtPath(hookPath);
+    return;
+  }
   if (!existsSync7(hookPath)) return;
   const existing = readFileSync6(hookPath, "utf-8");
   const primCreated = existing.includes(PRIM_CREATED_MARK);
@@ -4810,22 +4886,29 @@ function uninstallGlobalHooks() {
   console.log("No prim global git hooks found.");
 }
 function installHooks(gitRoot, target) {
-  for (const spec of HOOKS.filter((candidate) => candidate !== POST_COMMIT)) {
-    if (target === "husky") {
-      installToHusky(gitRoot, spec);
-    } else {
-      installToDotGit(gitRoot, spec);
-    }
+  if (target === "husky") {
+    installToHusky(gitRoot, PRE_COMMIT);
+  } else {
+    installToDotGit(gitRoot, PRE_COMMIT);
   }
   const postCommit = ensureEffectivePostCommitHook(gitRoot);
   console.log(
     `${postCommit.changed ? "Installed" : "Refreshed"} effective post-commit hook at ${postCommit.path}.`
   );
+  try {
+    const postRewrite = ensureEffectivePostRewriteHook(gitRoot);
+    console.log(
+      `${postRewrite.changed ? "Installed" : "Refreshed"} effective post-rewrite hook at ${postRewrite.path}.`
+    );
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.error(`[prim] post-rewrite hook coverage is degraded: ${detail}`);
+  }
 }
 function registerHooksCommands(program2) {
   const hooks = program2.command("hooks").description("Manage git hooks");
   hooks.command("install").description(
-    "Install the prim git hooks \u2014 pre-commit + post-commit (auto-detects Husky; use --target to override)"
+    "Install the prim git hooks \u2014 pre-commit + post-commit + post-rewrite (auto-detects Husky; use --target to override)"
   ).addOption(
     new Option3("--target <where>", "install destination; bypasses Husky detection").choices([
       "husky",
@@ -4883,27 +4966,30 @@ function registerHooksCommands(program2) {
     }
     const gitRoot = getGitRoot();
     const hooksDir = projectHooksDir(gitRoot);
-    for (const spec of HOOKS.filter((candidate) => candidate !== POST_COMMIT)) {
-      const hookPath = resolve2(hooksDir, spec.hookName);
-      if (!existsSync7(hookPath)) {
-        console.log(`No ${spec.hookName} hook found.`);
-        continue;
-      }
-      if (containsPrimHook(readFileSync6(hookPath, "utf-8"), spec.binName)) {
-        unlinkSync2(hookPath);
-        console.log(`Removed ${spec.hookName} hook at ${hookPath}`);
+    const preCommitPath = resolve2(hooksDir, PRE_COMMIT.hookName);
+    if (!existsSync7(preCommitPath)) {
+      console.log(`No ${PRE_COMMIT.hookName} hook found.`);
+    } else if (containsPrimHook(readFileSync6(preCommitPath, "utf-8"), PRE_COMMIT.binName)) {
+      unlinkSync2(preCommitPath);
+      console.log(`Removed ${PRE_COMMIT.hookName} hook at ${preCommitPath}`);
+    } else {
+      console.log(
+        `Left ${PRE_COMMIT.hookName} hook at ${preCommitPath} untouched (not a prim hook).`
+      );
+    }
+    for (const [hookName, uninstall] of [
+      [POST_COMMIT.hookName, uninstallProjectPostCommitHook],
+      [POST_REWRITE.hookName, uninstallProjectPostRewriteHook]
+    ]) {
+      const result = uninstall(gitRoot);
+      if (!result.changed) {
+        console.log(`No Prim ${hookName} block found at ${result.path}.`);
+      } else if (result.removedFile) {
+        console.log(`Removed Prim-created ${hookName} hook at ${result.path}.`);
       } else {
-        console.log(`Left ${spec.hookName} hook at ${hookPath} untouched (not a prim hook).`);
+        console.log(`Removed the Prim ${hookName} block from ${result.path}.`);
       }
     }
-    const postCommit = uninstallProjectPostCommitHook(gitRoot);
-    if (!postCommit.changed) {
-      console.log(`No Prim post-commit block found at ${postCommit.path}.`);
-    } else if (postCommit.removedFile) {
-      console.log(`Removed Prim-created post-commit hook at ${postCommit.path}.`);
-    } else {
-      console.log(`Removed the Prim post-commit block from ${postCommit.path}.`);
-    }
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primitive.ai/prim",
-  "version": "0.1.0-alpha.64",
+  "version": "0.1.0-alpha.66",
   "description": "CLI for Primitive's decision graph — passive decision capture, conflict gate, and team presence",
   "type": "module",
   "license": "MIT",
@@ -31,6 +31,7 @@
     "prim": "dist/index.js",
     "prim-pre-commit": "dist/hooks/pre-commit.js",
     "prim-post-commit": "dist/hooks/post-commit.js",
+    "prim-post-rewrite": "dist/hooks/post-rewrite.js",
     "prim-hook": "dist/hooks/prim-hook.js",
     "prim-pre-tool-use": "dist/hooks/pre-tool-use.js",
     "prim-post-tool-use": "dist/hooks/post-tool-use.js",
@@ -47,9 +48,9 @@
     "SKILL.md"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/hooks/pre-commit.ts src/hooks/post-commit.ts src/hooks/prim-hook.ts src/hooks/pre-tool-use.ts src/hooks/post-tool-use.ts src/hooks/session-start.ts src/hooks/session-end.ts --format esm --clean && tsup src/statusline-main.ts src/daemon/server.ts --format esm --splitting false",
-    "postbuild": "chmod +x ./dist/index.js ./dist/statusline-main.js ./dist/hooks/pre-commit.js ./dist/hooks/post-commit.js ./dist/hooks/prim-hook.js ./dist/hooks/pre-tool-use.js ./dist/hooks/post-tool-use.js ./dist/hooks/session-start.js ./dist/hooks/session-end.js ./dist/daemon/server.js",
-    "dev": "tsup src/index.ts src/statusline-main.ts src/hooks/pre-commit.ts src/hooks/post-commit.ts src/hooks/prim-hook.ts src/hooks/pre-tool-use.ts src/hooks/post-tool-use.ts src/hooks/session-start.ts src/hooks/session-end.ts src/daemon/server.ts --format esm --watch --clean --splitting false",
+    "build": "tsup src/index.ts src/hooks/pre-commit.ts src/hooks/post-commit.ts src/hooks/post-rewrite.ts src/hooks/prim-hook.ts src/hooks/pre-tool-use.ts src/hooks/post-tool-use.ts src/hooks/session-start.ts src/hooks/session-end.ts --format esm --clean && tsup src/statusline-main.ts src/daemon/server.ts --format esm --splitting false",
+    "postbuild": "chmod +x ./dist/index.js ./dist/statusline-main.js ./dist/hooks/pre-commit.js ./dist/hooks/post-commit.js ./dist/hooks/post-rewrite.js ./dist/hooks/prim-hook.js ./dist/hooks/pre-tool-use.js ./dist/hooks/post-tool-use.js ./dist/hooks/session-start.js ./dist/hooks/session-end.js ./dist/daemon/server.js",
+    "dev": "tsup src/index.ts src/statusline-main.ts src/hooks/pre-commit.ts src/hooks/post-commit.ts src/hooks/post-rewrite.ts src/hooks/prim-hook.ts src/hooks/pre-tool-use.ts src/hooks/post-tool-use.ts src/hooks/session-start.ts src/hooks/session-end.ts src/daemon/server.ts --format esm --watch --clean --splitting false",
     "clean": "rm -rf dist coverage",
     "lint": "biome check src/",
     "format": "biome check --fix src/",