mason-context 0.21.0 → 0.22.0

package/dist/mason-review.js

@@ -31,12 +31,12 @@ var init_types = __esm({
 });
 
 // src/review/cli.ts
-import path13 from "path";
+import path12 from "path";
 import { stripVTControlCharacters } from "util";
 
 // src/review/review.ts
 import fs7 from "fs/promises";
-import path12 from "path";
+import path11 from "path";
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify3 } from "util";
 
@@ -91,10 +91,7 @@ function execGit(args, options) {
 
 // src/drift/drift.ts
 import fs4 from "fs/promises";
-import path6 from "path";
-
-// src/snapshot/snapshot.ts
-import path5 from "path";
+import path4 from "path";
 
 // src/utils/validation.ts
 function isRecord(value) {
@@ -420,76 +417,6 @@ import fs3 from "fs/promises";
 import os from "os";
 var lockOwnerSchema = z.object({ host: z.string(), pid: z.number().int().positive() });
 
-// src/test-map.ts
-import path4 from "path";
-async function buildTestMap(dir) {
-  const rootDir = path4.resolve(dir);
-  const access = await createFileAccess(rootDir);
-  const testPatterns = [
-    "**/*.test.*",
-    "**/*.spec.*",
-    "**/*Test.kt",
-    "**/*Test.java",
-    "**/*Tests.kt",
-    "**/*Tests.java",
-    "**/test_*.py",
-    "**/*_test.py",
-    "**/*_test.go",
-    "**/*Tests.swift",
-    "**/*Test.swift",
-    "**/*_test.rs"
-  ];
-  const testFiles = await access.list(testPatterns);
-  const sourceFiles = await access.list();
-  const sourceByBaseName = /* @__PURE__ */ new Map();
-  for (const file of sourceFiles) {
-    if (testFiles.includes(file)) continue;
-    const baseName = path4.basename(file).replace(/\.[^.]+$/, "");
-    const existing = sourceByBaseName.get(baseName) ?? [];
-    existing.push(file);
-    sourceByBaseName.set(baseName, existing);
-  }
-  const paired = [];
-  const unmatched = [];
-  for (const testFile of testFiles) {
-    const testBaseName = path4.basename(testFile).replace(/\.[^.]+$/, "");
-    const sourceName = testBaseName.replace(/Test$|Tests$|Spec$|\.test$|\.spec$/, "").replace(/^test_|_test$/, "");
-    if (!sourceName) {
-      unmatched.push(testFile);
-      continue;
-    }
-    const candidates = sourceByBaseName.get(sourceName);
-    if (candidates && candidates.length > 0) {
-      const testDir = path4.dirname(testFile);
-      const bestMatch = candidates.reduce((best, candidate) => {
-        const candidateDir = path4.dirname(candidate);
-        const bestDir = path4.dirname(best);
-        const candidateOverlap = commonSegments(testDir, candidateDir);
-        const bestOverlap = commonSegments(testDir, bestDir);
-        return candidateOverlap > bestOverlap ? candidate : best;
-      });
-      paired.push({
-        test: testFile,
-        source: bestMatch,
-        confidence: candidates.length === 1 ? "exact" : "best-guess"
-      });
-    } else {
-      unmatched.push(testFile);
-    }
-  }
-  return { totalTestFiles: testFiles.length, paired, unmatched };
-}
-function commonSegments(pathA, pathB) {
-  const segsA = pathA.split("/");
-  const segsB = pathB.split("/");
-  let count2 = 0;
-  for (let i = 0; i < Math.min(segsA.length, segsB.length); i++) {
-    if (segsA[i] === segsB[i]) count2++;
-    else break;
-  }
-  return count2;
-}
-
 // src/snapshot/snapshot.ts
 var repoPath = z2.string().refine((value) => normalizeRepoPath(value) !== null, "Expected a relative repository path");
 var verificationFields = {
@@ -600,11 +527,11 @@ import fg3 from "fast-glob";
 // src/audit/inspection.ts
 import fg2 from "fast-glob";
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-import path7 from "path";
+import path5 from "path";
 var inspections = new AsyncLocalStorage2();
 function inspectionRead(root, key, read) {
   const inspection = inspections.getStore();
-  if (!inspection || inspection.root !== path7.resolve(root)) return read();
+  if (!inspection || inspection.root !== path5.resolve(root)) return read();
   if (!inspection.reads.has(key)) {
     const pending = read();
     inspection.reads.set(key, pending);
@@ -847,6 +774,7 @@ var currentSchema = legacySchema.extend({
       inspector: text(200),
       note: text(1500),
       outcome: z4.literal("no_contradiction_found"),
+      scope: z4.literal("operative").optional(),
       decisionDigest: z4.string().regex(/^[a-f0-9]{64}$/),
       headHash: z4.string(),
       capture: anchorCaptureSchema
@@ -957,8 +885,19 @@ function decisionTrust(record, freshness) {
     freshness
   );
 }
-function decisionInspectionDigest(record) {
+function decisionInspectionDigest(record, scope = "all") {
   const effective = effectiveDecision(record);
+  if (scope === "operative")
+    return createHash2("sha256").update(
+      JSON.stringify([
+        "operative",
+        record.status,
+        decisionApproval(effective),
+        effective.version === 2 ? effective.revision : 0,
+        decisionContent(effective),
+        effective.refreshedHash
+      ])
+    ).digest("hex");
   return createHash2("sha256").update(
     JSON.stringify([
       record.status,
@@ -970,8 +909,10 @@ function decisionInspectionDigest(record) {
     ])
   ).digest("hex");
 }
-function latestDecisionInspection(record) {
-  return record.version === 2 ? record.inspections?.filter((i) => i.decisionDigest === decisionInspectionDigest(record)).at(-1) : void 0;
+function latestDecisionInspection(record, scope = "all") {
+  return record.version === 2 ? record.inspections?.filter(
+    (i) => (scope === "operative" || i.scope !== "operative") && i.decisionDigest === decisionInspectionDigest(record, i.scope ?? "all")
+  ).at(-1) : void 0;
 }
 function revisionKnowledge(record, freshness) {
   return {
@@ -982,7 +923,10 @@ function revisionKnowledge(record, freshness) {
 }
 function decisionKnowledge(record, freshness = "unknown", proposalFreshness = "unknown") {
   const effective = effectiveDecision(record);
-  const inspection = latestDecisionInspection(record);
+  const inspection = latestDecisionInspection(
+    record,
+    decisionApproval(effective) === "accepted" ? "operative" : "all"
+  );
   return {
     ...revisionKnowledge(effective, freshness),
     ...inspection ? {
@@ -992,21 +936,27 @@ function decisionKnowledge(record, freshness = "unknown", proposalFreshness = "u
         inspector: inspection.inspector,
         note: inspection.note,
         outcome: inspection.outcome,
+        scope: inspection.scope ?? "all",
         headHash: inspection.headHash
       }
     } : {},
-    ...effective !== record ? { pendingProposal: revisionKnowledge(record, proposalFreshness) } : {}
+    ...effective !== record ? {
+      pendingProposal: {
+        ...revisionKnowledge(record, proposalFreshness),
+        assessment: latestDecisionInspection(record) ? "no_contradiction_found" : "not_assessed"
+      }
+    } : {}
   };
 }
 
 // src/decisions/decisions.ts
 import fs6 from "fs/promises";
-import path9 from "path";
+import path7 from "path";
 import { createHash as createHash3 } from "crypto";
 import { z as z5 } from "zod";
 
 // src/context/lexical.ts
-import path8 from "path";
+import path6 from "path";
 
 // src/decisions/decisions.ts
 var TITLE_MAX_CHARS = 80;
@@ -1085,9 +1035,9 @@ async function loadDecisionStore(rootDir) {
 }
 
 // src/decisions/drift.ts
-import path10 from "path";
+import path8 from "path";
 async function computeDecisionDrift(rootDir, decisions) {
-  const resolvedRoot = path10.resolve(rootDir);
+  const resolvedRoot = path8.resolve(rootDir);
   const store = decisions ? { records: decisions, diagnostics: [] } : await loadDecisionStore(resolvedRoot);
   const report = {
     historyAvailable: true,
@@ -1102,11 +1052,15 @@ async function computeDecisionDrift(rootDir, decisions) {
   ]);
   const changesByHash = /* @__PURE__ */ new Map();
   const baselines = store.records.filter((record) => record.status === "active").flatMap((record) => {
-    const inspection = latestDecisionInspection(record);
-    if (inspection) return [inspection.capture];
-    return [.../* @__PURE__ */ new Set([effectiveDecision(record), record])].flatMap(
-      (candidate) => candidate.version === 2 && candidate.capture ? [candidate.capture] : []
-    );
+    const effective = effectiveDecision(record);
+    return [.../* @__PURE__ */ new Set([effective, record])].flatMap((candidate) => {
+      const inspection = latestDecisionInspection(
+        record,
+        candidate === effective && decisionApproval(effective) === "accepted" ? "operative" : "all"
+      );
+      const capture = inspection?.capture ?? (candidate.version === 2 ? candidate.capture : void 0);
+      return capture ? [capture] : [];
+    });
   });
   const captures = await captureAnchorScopes(
     resolvedRoot,
@@ -1145,12 +1099,18 @@ async function computeDecisionDrift(rootDir, decisions) {
   for (const record of store.records) {
     if (record.status !== "active") continue;
     const effective = effectiveDecision(record);
-    const inspection = latestDecisionInspection(record);
+    const inspection = latestDecisionInspection(
+      record,
+      decisionApproval(effective) === "accepted" ? "operative" : "all"
+    );
     const state = await inspect(effective, inspection?.capture);
     report.freshness[record.id] = state.freshness;
     if (state.changedFiles.length) report.staleDecisions[record.id] = state.changedFiles;
     if (effective !== record)
-      (report.pendingProposals ??= {})[record.id] = await inspect(record, inspection?.capture);
+      (report.pendingProposals ??= {})[record.id] = await inspect(
+        record,
+        latestDecisionInspection(record)?.capture
+      );
   }
   return report;
 }
@@ -1228,9 +1188,79 @@ async function findMissingPartners(resolvedRoot, changedFiles, existsOnDisk, all
 }
 
 // src/review/evidence.ts
-import path11 from "path";
+import path10 from "path";
 import { z as z9 } from "zod";
 
+// src/test-map.ts
+import path9 from "path";
+async function buildTestMap(dir) {
+  const rootDir = path9.resolve(dir);
+  const access = await createFileAccess(rootDir);
+  const testPatterns = [
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/*Test.kt",
+    "**/*Test.java",
+    "**/*Tests.kt",
+    "**/*Tests.java",
+    "**/test_*.py",
+    "**/*_test.py",
+    "**/*_test.go",
+    "**/*Tests.swift",
+    "**/*Test.swift",
+    "**/*_test.rs"
+  ];
+  const testFiles = await access.list(testPatterns);
+  const sourceFiles = await access.list();
+  const sourceByBaseName = /* @__PURE__ */ new Map();
+  for (const file of sourceFiles) {
+    if (testFiles.includes(file)) continue;
+    const baseName = path9.basename(file).replace(/\.[^.]+$/, "");
+    const existing = sourceByBaseName.get(baseName) ?? [];
+    existing.push(file);
+    sourceByBaseName.set(baseName, existing);
+  }
+  const paired = [];
+  const unmatched = [];
+  for (const testFile of testFiles) {
+    const testBaseName = path9.basename(testFile).replace(/\.[^.]+$/, "");
+    const sourceName = testBaseName.replace(/Test$|Tests$|Spec$|\.test$|\.spec$/, "").replace(/^test_|_test$/, "");
+    if (!sourceName) {
+      unmatched.push(testFile);
+      continue;
+    }
+    const candidates = sourceByBaseName.get(sourceName);
+    if (candidates && candidates.length > 0) {
+      const testDir = path9.dirname(testFile);
+      const bestMatch = candidates.reduce((best, candidate) => {
+        const candidateDir = path9.dirname(candidate);
+        const bestDir = path9.dirname(best);
+        const candidateOverlap = commonSegments(testDir, candidateDir);
+        const bestOverlap = commonSegments(testDir, bestDir);
+        return candidateOverlap > bestOverlap ? candidate : best;
+      });
+      paired.push({
+        test: testFile,
+        source: bestMatch,
+        confidence: candidates.length === 1 ? "exact" : "best-guess"
+      });
+    } else {
+      unmatched.push(testFile);
+    }
+  }
+  return { totalTestFiles: testFiles.length, paired, unmatched };
+}
+function commonSegments(pathA, pathB) {
+  const segsA = pathA.split("/");
+  const segsB = pathB.split("/");
+  let count2 = 0;
+  for (let i = 0; i < Math.min(segsA.length, segsB.length); i++) {
+    if (segsA[i] === segsB[i]) count2++;
+    else break;
+  }
+  return count2;
+}
+
 // src/review/evidence/vitest.ts
 import { z as z6 } from "zod";
 
@@ -1622,7 +1652,7 @@ var checkSchema = z9.object({
   }).optional()
 });
 function relativeArtifact(root, file) {
-  const relative = path11.isAbsolute(file) ? path11.relative(root, file) : file;
+  const relative = path10.isAbsolute(file) ? path10.relative(root, file) : file;
   const normalized = normalizeRepoPath(relative);
   if (!normalized) throw new Error(`Evidence artifact must be inside the repository: ${file}`);
   return normalized;
@@ -1751,7 +1781,7 @@ async function collectReviewEvidence(root, manifests, changedFiles, decisions, d
         const report = await readStoreJson(root, file);
         if (report === null) throw new Error(`Report artifact is missing: ${file}`);
         const sourceRoot = check.sourceRoot ?? root;
-        if (!path11.posix.isAbsolute(sourceRoot) && !/^[A-Za-z]:[\\/]/.test(sourceRoot))
+        if (!path10.posix.isAbsolute(sourceRoot) && !/^[A-Za-z]:[\\/]/.test(sourceRoot))
           throw new Error(
             "sourceRoot must identify the absolute checkout root on the check runner."
           );
@@ -1856,7 +1886,7 @@ function anchorsTouched(record, changedFiles) {
   return matchingPaths(record.files, changedFiles);
 }
 async function computeReview(rootDir, base, options = {}) {
-  const resolvedRoot = path12.resolve(rootDir);
+  const resolvedRoot = path11.resolve(rootDir);
   const head = await getCurrentGitHash(resolvedRoot);
   if (head === "unknown") return null;
   const mergeBase = await resolveMergeBase(resolvedRoot, base, head);
@@ -1917,7 +1947,7 @@ async function computeReview(rootDir, base, options = {}) {
     analyzed,
     async (relPath) => {
       try {
-        await fs7.access(path12.join(resolvedRoot, relPath));
+        await fs7.access(path11.join(resolvedRoot, relPath));
         return true;
       } catch {
         return false;
@@ -2152,7 +2182,7 @@ async function runReviewCli(argv, io = {
     io.out(USAGE);
     return 0;
   }
-  const rootDir = path13.resolve(args.dir);
+  const rootDir = path12.resolve(args.dir);
   const base = args.base ?? await defaultBase(rootDir);
   if (!base) {
     io.err(