mason-context 0.22.0 → 0.23.0

package/dist/mason-hook.js

@@ -421,6 +421,7 @@ async function storePath(root, relative, createParents = false) {
   }
   return current;
 }
+var STORE_MAX_BYTES = 10 * 1024 * 1024;
 
 // src/decisions/anchors.ts
 var repoPath = z.string().refine((p) => normalizeRepoPath(p) === p);
@@ -443,7 +444,12 @@ async function captureAnchorScopes(root, scopes) {
     );
     const inventory = access.inventory();
     if (!inventory) throw new Error("Git anchor inventory unavailable");
-    const ignored = await inspectionGit(
+    const visible = indexMatchingPaths(
+      union.map((anchor) => [anchor]),
+      inventory
+    );
+    const hidden = new Set(union.filter((_, index) => !visible[index].length));
+    const ignored = hidden.size ? (await inspectionGit(
       [
         "ls-files",
         "-z",
@@ -451,13 +457,11 @@ async function captureAnchorScopes(root, scopes) {
         "--ignored",
         "--exclude-standard",
         "--",
-        ...union.map((anchor) => `:(literal)${anchor}`)
+        ...[...hidden].map((anchor) => `:(literal)${anchor}`)
       ],
       { cwd: root, maxBuffer: 8 * 1024 * 1024 }
-    );
-    const files = [
-      .../* @__PURE__ */ new Set([...inventory, ...ignored.stdout.split("\0").filter(Boolean)])
-    ].sort();
+    )).stdout.split("\0").filter(Boolean) : [];
+    const files = [.../* @__PURE__ */ new Set([...inventory, ...ignored])].sort();
     const patterns = await Promise.all(
       union.map(async (anchor) => {
         const literal = fg3.escapePath(anchor);
@@ -473,7 +477,7 @@ async function captureAnchorScopes(root, scopes) {
     const filesByScope = new Map(
       scopes.map((scope, index) => [JSON.stringify([...new Set(scope)].sort()), indexed[index]])
     );
-    return { filesByScope, eligible };
+    return { filesByScope, eligible, hidden, ignored: new Set(ignored) };
   };
   return Promise.all(
     scopes.map((scope) => {
@@ -485,8 +489,10 @@ async function captureAnchorScopes(root, scopes) {
           const capture = { anchors, files: {}, complete: true };
           if (!anchors.length) return capture;
           try {
-            const { eligible, filesByScope } = await (context ??= prepareContext());
-            const files = filesByScope.get(JSON.stringify(anchors));
+            const { eligible, filesByScope, hidden, ignored } = await (context ??= prepareContext());
+            const files = filesByScope.get(JSON.stringify(anchors)).filter(
+              (file) => !ignored.has(file) || anchors.some((anchor) => hidden.has(anchor) && anchorMatches(anchor, file))
+            );
             if (files.length > 2e3) return { ...capture, complete: false };
             for (const file of files) {
               const evidence = await inspectionRead(
@@ -960,7 +966,7 @@ async function loadDecisionStore(rootDir) {
 }
 
 // src/hook/hook.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 
 // src/decisions/drift.ts
 import path8 from "path";
@@ -1026,6 +1032,26 @@ async function getWorkingTree(resolvedRoot) {
   }
 }
 
+// src/decisions/excerpts.ts
+import { createHash as createHash4 } from "crypto";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var exec = promisify2(execFile2);
+function driftBaseline(record) {
+  const effective = effectiveDecision(record);
+  const inspection = latestDecisionInspection(
+    record,
+    decisionApproval(effective) === "accepted" ? "operative" : "all"
+  );
+  return {
+    record: effective,
+    capture: inspection?.capture ?? (effective.version === 2 ? effective.capture : void 0),
+    commits: [inspection?.headHash, effective.refreshedHash].filter(
+      (hash) => !!hash && /^[a-f0-9]{40,64}$/.test(hash)
+    )
+  };
+}
+
 // src/decisions/drift.ts
 async function computeDecisionDrift(rootDir, decisions) {
   const resolvedRoot = path8.resolve(rootDir);
@@ -1089,15 +1115,11 @@ async function computeDecisionDrift(rootDir, decisions) {
   };
   for (const record of store.records) {
     if (record.status !== "active") continue;
-    const effective = effectiveDecision(record);
-    const inspection = latestDecisionInspection(
-      record,
-      decisionApproval(effective) === "accepted" ? "operative" : "all"
-    );
-    const state = await inspect(effective, inspection?.capture);
+    const baseline = driftBaseline(record);
+    const state = await inspect(baseline.record, baseline.capture);
     report.freshness[record.id] = state.freshness;
     if (state.changedFiles.length) report.staleDecisions[record.id] = state.changedFiles;
-    if (effective !== record)
+    if (baseline.record !== record)
       (report.pendingProposals ??= {})[record.id] = await inspect(
         record,
         latestDecisionInspection(record)?.capture
@@ -1209,10 +1231,10 @@ async function runHook(stdinText, env = {}) {
   const stateDir = env.stateDir ?? os2.tmpdir();
   const stateFile = path9.join(
     stateDir,
-    `mason-hook-${createHash4("sha256").update(root).digest("hex").slice(0, 12)}-${stateKey(input)}.json`
+    `mason-hook-${createHash5("sha256").update(root).digest("hex").slice(0, 12)}-${stateKey(input)}.json`
   );
   const injected = await loadInjected(stateFile);
-  const recordKey = (record) => `${record.id}:${createHash4("sha256").update(JSON.stringify(record)).digest("hex")}`;
+  const recordKey = (record) => `${record.id}:${createHash5("sha256").update(JSON.stringify(record)).digest("hex")}`;
   const previouslyInjected = (record) => [...injected].some((key) => key === record.id || key.startsWith(`${record.id}:`));
   const fresh = records.filter(
     (r) => !injected.has(recordKey(r)) && (previouslyInjected(r) || r.status === "active" && anchorsCover(r, relPath))