mason-context 0.17.3 → 0.18.0

package/dist/mason-drift.js

@@ -3,23 +3,54 @@
 // src/drift/cli.ts
 import path10 from "path";
 
+// 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/drift/drift.ts
-import fs3 from "fs/promises";
+import fs4 from "fs/promises";
 import path6 from "path";
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
 
 // src/snapshot/snapshot.ts
 import path5 from "path";
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
 
 // 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";
 
 // src/utils/paths.ts
@@ -45,7 +76,6 @@ function matchingPaths(anchors, files) {
 }
 
 // src/utils/files.ts
-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 SOURCE_IGNORE = [
@@ -124,12 +154,12 @@ async function createFileAccess(rootDir) {
   const ignore = [...SOURCE_IGNORE, ...config.ignore ?? []];
   let gitFiles = null;
   try {
-    const { stdout } = await exec("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], { cwd: root, maxBuffer: 50 * 1024 * 1024 });
+    const { stdout } = await execGit(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], { cwd: root, maxBuffer: 50 * 1024 * 1024 });
     gitFiles = new Set(stdout.split("\0").filter(Boolean));
   } catch {
     let inGit = false;
     try {
-      await exec("git", ["rev-parse", "--git-dir"], { cwd: root });
+      await execGit(["rev-parse", "--git-dir"], { cwd: root });
       inGit = true;
     } catch {
     }
@@ -219,16 +249,20 @@ async function readStoreJson(root, relative) {
 // src/snapshot/snapshot.ts
 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()
 };
@@ -257,7 +291,7 @@ async function loadSnapshot(rootDir) {
 }
 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();
@@ -270,7 +304,6 @@ async function listSourceFiles(resolvedRoot) {
 }
 
 // src/drift/drift.ts
-var exec3 = promisify3(execFile3);
 var FULL_REBUILD_FRACTION = 0.4;
 var FULL_REBUILD_MIN_CHANGED_MAPPED_FILES = 10;
 function parseChanges(output) {
@@ -293,7 +326,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;
@@ -302,8 +335,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 };
@@ -314,8 +347,7 @@ async function getWorkingTree(resolvedRoot) {
 async function countCommitsBehind(resolvedRoot, fromHash) {
   if (!fromHash || fromHash === "unknown" || fromHash.startsWith("-")) return null;
   try {
-    const { stdout } = await exec3(
-      "git",
+    const { stdout } = await execGit(
       ["rev-list", "--count", `${fromHash}..HEAD`],
       { cwd: resolvedRoot }
     );
@@ -340,7 +372,7 @@ async function findGhostFiles(resolvedRoot, mappedFiles) {
   const ghosts = [];
   for (const file of mappedFiles) {
     try {
-      await fs3.access(path6.join(resolvedRoot, file));
+      await fs4.access(path6.join(resolvedRoot, file));
     } catch {
       ghosts.push(file);
     }
@@ -405,7 +437,7 @@ async function computeDrift(rootDir) {
   const sourceFiles = new Set(await listSourceFiles(root));
   let committedFiles = /* @__PURE__ */ new Set();
   try {
-    const { stdout } = await exec3("git", ["ls-tree", "-r", "--name-only", "-z", "HEAD"], { cwd: root, maxBuffer: 50 * 1024 * 1024 });
+    const { stdout } = await execGit(["ls-tree", "-r", "--name-only", "-z", "HEAD"], { cwd: root, maxBuffer: 50 * 1024 * 1024 });
     committedFiles = new Set(stdout.split("\0").filter(Boolean));
   } catch {
     report.historyAvailable = false;
@@ -430,7 +462,7 @@ async function computeDrift(rootDir) {
 import path9 from "path";
 
 // src/decisions/decisions.ts
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import path8 from "path";
 import { createHash } from "crypto";
 import { z as z3 } from "zod";
@@ -577,7 +609,7 @@ async function loadDecisionStore(rootDir) {
   const diagnostics = [];
   let entries;
   try {
-    entries = await fs4.readdir(await storePath(rootDir, ".mason/decisions"));
+    entries = await fs5.readdir(await storePath(rootDir, ".mason/decisions"));
   } catch (error) {
     if (error.code !== "ENOENT") diagnostics.push({ path: ".mason/decisions", message: String(error) });
     return { records, diagnostics };