mason-context 0.17.3 → 0.18.0

package/dist/mason-hook.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/hook/hook.ts
-import fs5 from "fs/promises";
+import fs6 from "fs/promises";
 import path10 from "path";
-import os from "os";
+import os2 from "os";
 
 // src/decisions/decisions.ts
-import fs3 from "fs/promises";
+import fs4 from "fs/promises";
 import path7 from "path";
 import { createHash } from "crypto";
 import { z as z3 } from "zod";
@@ -34,14 +34,48 @@ function matchingPaths(anchors, files) {
   return [...new Set(files)].filter((file) => anchors.some((anchor) => anchorMatches(anchor, file)));
 }
 
+// src/utils/git-read.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/utils/profile.ts
+import { AsyncLocalStorage } from "async_hooks";
+var profiles = new AsyncLocalStorage();
+async function profilePhase(label, run) {
+  const phases = profiles.getStore();
+  if (!phases) return run();
+  const start = performance.now();
+  try {
+    return await run();
+  } finally {
+    const timing = phases[label] ??= { calls: 0, totalMs: 0 };
+    timing.calls++;
+    timing.totalMs += performance.now() - start;
+  }
+}
+
+// src/utils/git-read.ts
+var execute = promisify(execFile);
+var commands = /* @__PURE__ */ new Set(["rev-parse", "symbolic-ref", "for-each-ref", "ls-files", "check-ignore", "status", "log", "diff", "ls-tree", "show", "merge-base"]);
+function execGit(args, options) {
+  const command = args.find((arg) => !arg.startsWith("-")) ?? "other";
+  return profilePhase("git." + (commands.has(command) ? command : "other"), async () => {
+    const { input, ...processOptions } = options;
+    const operation = execute("git", args, processOptions);
+    if (input !== void 0) {
+      operation.child.stdin.on("error", () => {
+      });
+      operation.child.stdin.end(input);
+    }
+    return operation;
+  });
+}
+
 // src/utils/files.ts
 import fs from "fs/promises";
 import { constants } from "fs";
 import path2 from "path";
-import { execFile } from "child_process";
-import { promisify } from "util";
 import fg from "fast-glob";
-var exec = promisify(execFile);
 var SOURCE_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "cts", "mjs", "cjs", "vue", "svelte", "kt", "kts", "java", "py", "go", "rs", "swift", "rb", "cs", "cpp", "c", "h", "hpp", "dart", "php"];
 var SOURCE_GLOB = `**/*.{${SOURCE_EXTENSIONS.join(",")}}`;
 var MAX_SOURCE_BYTES = 1024 * 1024;
@@ -105,20 +139,22 @@ async function readStoreJson(root, relative) {
 
 // src/snapshot/snapshot.ts
 import path5 from "path";
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
 import { z } from "zod";
 
+// src/utils/store-lock.ts
+import fs3 from "fs/promises";
+import os from "os";
+
 // src/test-map.ts
 import path4 from "path";
 
 // src/snapshot/snapshot.ts
-var exec2 = promisify2(execFile2);
 var repoPath = z.string().refine((value) => normalizeRepoPath(value) !== null, "Expected a relative repository path");
 var verificationFields = {
   refreshedHash: z.string().optional(),
   verifiedAt: z.string().optional(),
   verifiedHash: z.string().optional(),
+  verificationToken: z.string().optional(),
   verificationFailed: z.boolean().optional(),
   verificationNote: z.string().optional()
 };
@@ -140,7 +176,7 @@ var snapshotSchema = z.object({
 }).passthrough();
 async function getCurrentGitHash(rootDir) {
   try {
-    const { stdout } = await exec2("git", ["rev-parse", "HEAD"], {
+    const { stdout } = await execGit(["rev-parse", "HEAD"], {
       cwd: rootDir
     });
     return stdout.trim();
@@ -338,7 +374,7 @@ async function loadDecisionStore(rootDir) {
   const diagnostics = [];
   let entries;
   try {
-    entries = await fs3.readdir(await storePath(rootDir, ".mason/decisions"));
+    entries = await fs4.readdir(await storePath(rootDir, ".mason/decisions"));
   } catch (error) {
     if (error.code !== "ENOENT") diagnostics.push({ path: ".mason/decisions", message: String(error) });
     return { records, diagnostics };
@@ -364,11 +400,8 @@ import { createHash as createHash2 } from "crypto";
 import path9 from "path";
 
 // src/drift/drift.ts
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import path8 from "path";
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-var exec3 = promisify3(execFile3);
 function parseChanges(output) {
   const fields = output.split("\0");
   const changes = [];
@@ -389,7 +422,7 @@ function touchedPaths(changes) {
 async function getChangesWithStatus(resolvedRoot, fromHash, toHash = "HEAD") {
   if (!fromHash || fromHash === "unknown" || fromHash.startsWith("-") || !toHash || toHash === "unknown" || toHash.startsWith("-")) return null;
   try {
-    const { stdout } = await exec3("git", ["diff", "--name-status", "-z", "-M", fromHash, toHash, "--"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 });
+    const { stdout } = await execGit(["diff", "--name-status", "-z", "-M", fromHash, toHash, "--"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 });
     return parseChanges(stdout);
   } catch {
     return null;
@@ -398,8 +431,8 @@ async function getChangesWithStatus(resolvedRoot, fromHash, toHash = "HEAD") {
 async function getWorkingTree(resolvedRoot) {
   try {
     const [diff, untracked] = await Promise.all([
-      exec3("git", ["diff", "--name-status", "-z", "-M", "HEAD", "--"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 }),
-      exec3("git", ["ls-files", "-z", "--others", "--exclude-standard"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 })
+      execGit(["diff", "--name-status", "-z", "-M", "HEAD", "--"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 }),
+      execGit(["ls-files", "-z", "--others", "--exclude-standard"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 })
     ]);
     const untrackedFiles = untracked.stdout.split("\0").filter((f) => f && !f.startsWith(".mason/"));
     return { available: true, changedFiles: [.../* @__PURE__ */ new Set([...touchedPaths(parseChanges(diff.stdout)), ...untrackedFiles])].sort(), untrackedFiles };
@@ -445,7 +478,7 @@ var MAX_WALK_UP = 30;
 var SUPPORTED_TOOLS = /* @__PURE__ */ new Set(["Read", "Edit", "Write"]);
 async function exists(p) {
   try {
-    await fs5.access(p);
+    await fs6.access(p);
     return true;
   } catch {
     return false;
@@ -474,7 +507,7 @@ function stateKey(input) {
 }
 async function loadInjected(stateFile) {
   try {
-    const parsed = JSON.parse(await fs5.readFile(stateFile, "utf-8"));
+    const parsed = JSON.parse(await fs6.readFile(stateFile, "utf-8"));
     return new Set(Array.isArray(parsed) ? parsed.filter((x) => typeof x === "string") : []);
   } catch {
     return /* @__PURE__ */ new Set();
@@ -515,7 +548,7 @@ async function runHook(stdinText, env = {}) {
   const relPath = path10.relative(root, absPath).split(path10.sep).join("/");
   if (relPath.startsWith("..")) return null;
   const { records } = await loadDecisionStore(root);
-  const stateDir = env.stateDir ?? os.tmpdir();
+  const stateDir = env.stateDir ?? os2.tmpdir();
   const stateFile = path10.join(stateDir, `mason-hook-${createHash2("sha256").update(root).digest("hex").slice(0, 12)}-${stateKey(input)}.json`);
   const injected = await loadInjected(stateFile);
   const recordKey = (record) => `${record.id}:${createHash2("sha256").update(JSON.stringify(record)).digest("hex")}`;
@@ -533,7 +566,7 @@ async function runHook(stdinText, env = {}) {
   const drift = await computeDecisionDrift(root, selected);
   for (const record of selected) injected.add(recordKey(record));
   try {
-    await fs5.writeFile(stateFile, JSON.stringify([...injected]), "utf-8");
+    await fs6.writeFile(stateFile, JSON.stringify([...injected]), "utf-8");
   } catch {
   }
   return JSON.stringify({