mason-context 0.16.2 → 0.17.0

package/dist/mason-review.js

@@ -542,11 +542,24 @@ function decisionKnowledge(record, freshness = "unknown", proposalFreshness = "u
 import fs4 from "fs/promises";
 import path8 from "path";
 import { createHash } from "crypto";
+import { z as z3 } from "zod";
 
 // src/context/lexical.ts
 import path7 from "path";
 
 // src/decisions/decisions.ts
+var TITLE_MAX_CHARS = 80;
+var BODY_RECOMMENDED_CHARS = 1500;
+var BODY_MAX_CHARS = 2500;
+var boundedText = (field, max, hint) => z3.string({
+  errorMap: (issue, ctx) => ({ message: issue.code === "too_big" ? `${field} has ${ctx.data.length} characters; maximum is ${max} (${ctx.data.length - max} over). ${hint}` : ctx.defaultError })
+}).trim().min(1, `${field} must be non-empty`).max(max);
+var decisionTitleSchema = boundedText("title", TITLE_MAX_CHARS, "Tighten it to a specific headline.");
+var decisionBodySchema = boundedText(
+  "body",
+  BODY_MAX_CHARS,
+  `Aim for ${BODY_RECOMMENDED_CHARS} characters or fewer. Preserve the rule, reason, and exceptions; put supporting references in sources.`
+);
 async function loadDecisionStore(rootDir) {
   const records = [];
   const diagnostics = [];
@@ -675,10 +688,10 @@ async function findMissingPartners(resolvedRoot, changedFiles, existsOnDisk, all
 
 // src/review/evidence.ts
 import path10 from "path";
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 
 // src/review/evidence/vitest.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/review/evidence/paths.ts
 function evidencePath(value, sourceRoot, uri = false) {
@@ -714,24 +727,24 @@ function messagePreview(message2) {
 }
 
 // src/review/evidence/vitest.ts
-var count = z3.number().int().nonnegative();
-var schema = z3.object({
-  success: z3.boolean(),
+var count = z4.number().int().nonnegative();
+var schema = z4.object({
+  success: z4.boolean(),
   numTotalTests: count,
   numPassedTests: count,
   numFailedTests: count,
   numPendingTests: count,
   numTodoTests: count,
   numFailedTestSuites: count,
-  testResults: z3.array(z3.object({
-    name: z3.string().min(1),
-    status: z3.enum(["passed", "failed"]),
-    message: z3.string().optional(),
-    assertionResults: z3.array(z3.object({
-      fullName: z3.string(),
-      status: z3.enum(["passed", "failed", "pending", "skipped", "todo", "disabled"]),
-      failureMessages: z3.array(z3.string()).nullable().optional(),
-      location: z3.object({ line: count, column: count }).nullable().optional()
+  testResults: z4.array(z4.object({
+    name: z4.string().min(1),
+    status: z4.enum(["passed", "failed"]),
+    message: z4.string().optional(),
+    assertionResults: z4.array(z4.object({
+      fullName: z4.string(),
+      status: z4.enum(["passed", "failed", "pending", "skipped", "todo", "disabled"]),
+      failureMessages: z4.array(z4.string()).nullable().optional(),
+      location: z4.object({ line: count, column: count }).nullable().optional()
     }))
   }))
 });
@@ -779,30 +792,30 @@ function parseVitest(raw, sourceRoot) {
 }
 
 // src/review/evidence/sarif.ts
-import { z as z4 } from "zod";
-var index = z4.number().int().nonnegative();
-var artifact = z4.object({ uri: z4.string().optional(), uriBaseId: z4.string().optional(), index: index.optional() });
-var message = z4.object({ text: z4.string().optional(), markdown: z4.string().optional(), id: z4.string().optional(), arguments: z4.array(z4.string()).optional() });
-var level = z4.enum(["error", "warning", "note", "none"]);
-var location = z4.object({ physicalLocation: z4.object({ artifactLocation: artifact.optional(), region: z4.object({ startLine: index.optional(), startColumn: index.optional() }).optional() }).optional() });
-var schema2 = z4.object({
-  version: z4.literal("2.1.0"),
-  runs: z4.array(z4.object({
-    tool: z4.object({ driver: z4.object({ name: z4.string().min(1), rules: z4.array(z4.object({ id: z4.string(), defaultConfiguration: z4.object({ level: level.optional() }).optional(), messageStrings: z4.record(message).optional() })).optional(), globalMessageStrings: z4.record(message).optional() }) }),
-    invocations: z4.array(z4.object({ executionSuccessful: z4.boolean(), commandLine: z4.string().optional(), toolExecutionNotifications: z4.array(z4.object({ level: level.optional(), message })).optional() })).optional(),
-    versionControlProvenance: z4.array(z4.object({ revisionId: z4.string().optional() })).optional(),
-    originalUriBaseIds: z4.record(artifact).optional(),
-    artifacts: z4.array(z4.object({ location: artifact.optional() })).optional(),
-    results: z4.array(z4.object({
-      ruleId: z4.string().optional(),
+import { z as z5 } from "zod";
+var index = z5.number().int().nonnegative();
+var artifact = z5.object({ uri: z5.string().optional(), uriBaseId: z5.string().optional(), index: index.optional() });
+var message = z5.object({ text: z5.string().optional(), markdown: z5.string().optional(), id: z5.string().optional(), arguments: z5.array(z5.string()).optional() });
+var level = z5.enum(["error", "warning", "note", "none"]);
+var location = z5.object({ physicalLocation: z5.object({ artifactLocation: artifact.optional(), region: z5.object({ startLine: index.optional(), startColumn: index.optional() }).optional() }).optional() });
+var schema2 = z5.object({
+  version: z5.literal("2.1.0"),
+  runs: z5.array(z5.object({
+    tool: z5.object({ driver: z5.object({ name: z5.string().min(1), rules: z5.array(z5.object({ id: z5.string(), defaultConfiguration: z5.object({ level: level.optional() }).optional(), messageStrings: z5.record(message).optional() })).optional(), globalMessageStrings: z5.record(message).optional() }) }),
+    invocations: z5.array(z5.object({ executionSuccessful: z5.boolean(), commandLine: z5.string().optional(), toolExecutionNotifications: z5.array(z5.object({ level: level.optional(), message })).optional() })).optional(),
+    versionControlProvenance: z5.array(z5.object({ revisionId: z5.string().optional() })).optional(),
+    originalUriBaseIds: z5.record(artifact).optional(),
+    artifacts: z5.array(z5.object({ location: artifact.optional() })).optional(),
+    results: z5.array(z5.object({
+      ruleId: z5.string().optional(),
       ruleIndex: index.optional(),
       message,
       level: level.optional(),
-      kind: z4.enum(["fail", "pass", "open", "informational", "notApplicable", "review"]).optional(),
-      baselineState: z4.enum(["new", "unchanged", "updated", "absent"]).optional(),
-      suppressions: z4.array(z4.object({ kind: z4.enum(["inSource", "external"]), status: z4.enum(["accepted", "underReview", "rejected"]).optional() })).nullable().optional(),
-      locations: z4.array(location).optional(),
-      relatedLocations: z4.array(location).optional()
+      kind: z5.enum(["fail", "pass", "open", "informational", "notApplicable", "review"]).optional(),
+      baselineState: z5.enum(["new", "unchanged", "updated", "absent"]).optional(),
+      suppressions: z5.array(z5.object({ kind: z5.enum(["inSource", "external"]), status: z5.enum(["accepted", "underReview", "rejected"]).optional() })).nullable().optional(),
+      locations: z5.array(location).optional(),
+      relatedLocations: z5.array(location).optional()
     })).optional()
   }))
 });
@@ -891,20 +904,76 @@ function parseSarif(raw, sourceRoot) {
   };
 }
 
+// src/review/evidence/check.ts
+import { z as z6 } from "zod";
+var schema3 = z6.object({
+  version: z6.literal(1),
+  commit: z6.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).optional(),
+  results: z6.array(z6.object({
+    name: z6.string().min(1).max(1e3),
+    status: z6.enum(["passed", "failed", "skipped"]),
+    message: z6.string().max(1e5).optional(),
+    locations: z6.array(z6.object({
+      file: z6.string().min(1).max(4e3),
+      line: z6.number().int().positive().optional(),
+      column: z6.number().int().positive().optional()
+    })).max(100).default([])
+  })).max(1e5)
+});
+function parseCheck(raw, sourceRoot) {
+  const report = schema3.parse(raw);
+  const diagnostics = [], findings = [];
+  const counts = { total: report.results.length, passed: 0, failed: 0, skipped: 0 };
+  for (const [index2, result] of report.results.entries()) {
+    counts[result.status]++;
+    const locations = result.locations.flatMap((location2) => {
+      const file = evidencePath(location2.file, sourceRoot);
+      if (!file) {
+        diagnostics.push(`Check location is outside the declared checkout or invalid: ${location2.file}`);
+        return [];
+      }
+      return [{ ...location2, file }];
+    });
+    if (result.status === "failed") findings.push({
+      id: String(index2),
+      ...messagePreview([result.name, result.message].filter(Boolean).join("\n")),
+      severity: "error",
+      state: "active",
+      locations
+    });
+  }
+  if (!counts.total) diagnostics.push("No check results were recorded; an empty report is not passing evidence.");
+  if (counts.skipped) diagnostics.push(`${counts.skipped} checks were skipped; verification is incomplete.`);
+  return {
+    outcome: counts.failed ? "failed" : !counts.total ? "unavailable" : !counts.passed ? "skipped" : "passed",
+    counts,
+    findings,
+    incomplete: diagnostics.length > 0,
+    diagnostics,
+    ...report.commit ? { reportedCommits: [report.commit] } : {}
+  };
+}
+
 // src/review/evidence.ts
-var checkSchema = z5.object({
-  id: z5.string().min(1).max(100),
-  kind: z5.enum(["tests", "static-analysis", "security", "complexity", "duplication"]),
-  tool: z5.string().min(1).max(200),
-  command: z5.string().min(1).max(2e3),
-  commit: z5.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).nullable().optional(),
-  workingTreeClean: z5.boolean().optional(),
-  source: z5.string().max(2e3).optional(),
-  sourceRoot: z5.string().min(1).max(4e3).optional(),
-  status: z5.enum(["completed", "skipped", "unavailable"]).default("completed"),
-  reason: z5.string().min(1).max(2e3).optional(),
-  exitCode: z5.number().int().nullable().optional(),
-  report: z5.object({ format: z5.enum(["vitest-json", "sarif"]), path: z5.string().min(1).max(4e3) }).optional()
+var checkSchema = z7.object({
+  id: z7.string().min(1).max(100),
+  kind: z7.enum(["tests", "static-analysis", "security", "complexity", "duplication", "documentation"]),
+  tool: z7.string().min(1).max(200),
+  command: z7.string().min(1).max(2e3),
+  commit: z7.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).nullable().optional(),
+  workingTreeClean: z7.boolean().optional(),
+  source: z7.string().max(2e3).optional(),
+  sourceRoot: z7.string().min(1).max(4e3).optional(),
+  status: z7.enum(["completed", "skipped", "unavailable"]).default("completed"),
+  reason: z7.string().min(1).max(2e3).optional(),
+  exitCode: z7.number().int().nullable().optional(),
+  environment: z7.object({
+    toolVersion: z7.string().min(1).max(200),
+    runtime: z7.string().min(1).max(200).optional(),
+    platform: z7.string().min(1).max(200).optional(),
+    configuration: z7.array(z7.string().min(1).max(4e3)).max(100).optional()
+  }).optional(),
+  report: z7.object({ format: z7.enum(["vitest-json", "sarif", "mason-check-json"]), path: z7.string().min(1).max(4e3) }).optional()
 });
 function relativeArtifact(root, file) {
   const relative = path10.isAbsolute(file) ? path10.relative(root, file) : file;
@@ -946,7 +1015,7 @@ async function collectReviewEvidence(root, manifests, changedFiles, decisions, d
     let manifest, raw;
     try {
       manifest = relativeArtifact(root, supplied);
-      raw = z5.object({ version: z5.literal(1), checks: z5.array(z5.unknown()) }).parse(await readStoreJson(root, manifest));
+      raw = z7.object({ version: z7.literal(1), checks: z7.array(z7.unknown()) }).parse(await readStoreJson(root, manifest));
     } catch (error) {
       output.diagnostics.push(`${supplied}: ${String(error)}`);
       continue;
@@ -985,7 +1054,8 @@ async function collectReviewEvidence(root, manifests, changedFiles, decisions, d
         counts: {},
         incomplete: false,
         diagnostics: [],
-        truncated: false
+        truncated: false,
+        ...check.environment ? { environment: check.environment } : {}
       };
       output.checks.push(result);
       if (check.workingTreeClean !== true) result.diagnostics.push("The check's working tree was dirty or not recorded; its results cannot be attributed to the claimed commit alone.");
@@ -998,13 +1068,13 @@ async function collectReviewEvidence(root, manifests, changedFiles, decisions, d
       }
       try {
         if (!check.report) throw new Error("Completed check has no report artifact.");
-        if (check.kind === "tests" !== (check.report.format === "vitest-json")) throw new Error("Test checks require vitest-json; analysis checks require sarif.");
+        if (check.report.format !== "mason-check-json" && check.kind === "tests" !== (check.report.format === "vitest-json")) throw new Error("Test checks require vitest-json or mason-check-json; analysis checks require sarif or mason-check-json.");
         const file = relativeArtifact(root, check.report.path);
         const report = await readStoreJson(root, file);
         if (report === null) throw new Error(`Report artifact is missing: ${file}`);
         const sourceRoot = check.sourceRoot ?? root;
         if (!path10.posix.isAbsolute(sourceRoot) && !/^[A-Za-z]:[\\/]/.test(sourceRoot)) throw new Error("sourceRoot must identify the absolute checkout root on the check runner.");
-        const parsed = check.report.format === "vitest-json" ? parseVitest(report, sourceRoot) : parseSarif(report, sourceRoot);
+        const parsed = check.report.format === "vitest-json" ? parseVitest(report, sourceRoot) : check.report.format === "mason-check-json" ? parseCheck(report, sourceRoot) : parseSarif(report, sourceRoot);
         result.outcome = parsed.outcome;
         result.counts = parsed.counts;
         result.incomplete = parsed.incomplete;
@@ -1024,7 +1094,7 @@ async function collectReviewEvidence(root, manifests, changedFiles, decisions, d
           result.outcome = "failed";
           result.diagnostics.push(`Check command exited ${check.exitCode} despite a report with no active failures.`);
         }
-        if (check.report.format === "vitest-json" && pairs === void 0) {
+        if (check.kind === "tests" && pairs === void 0) {
           try {
             pairs = (await buildTestMap(root)).paired;
           } catch (error) {
@@ -1246,6 +1316,10 @@ function evidenceSummary(report) {
   for (const check of evidence.checks) {
     lines.push(`  [${check.kind}] ${display(check.id)}: ${check.outcome}, ${check.freshness} (${display(check.tool)})`);
     lines.push(`    command: ${display(check.command)}; tested commit: ${check.commit ?? "unknown"}`);
+    if (check.environment) {
+      lines.push(`    environment: ${display(check.tool)} ${display(check.environment.toolVersion)}` + (check.environment.runtime ? `; ${display(check.environment.runtime)}` : "") + (check.environment.platform ? `; ${display(check.environment.platform)}` : ""));
+      if (check.environment.configuration?.length) lines.push("    configuration: " + check.environment.configuration.map((value) => display(value)).join(", "));
+    }
     lines.push(`    source: ${display(check.source ?? check.manifest)}; report: ${display(check.report?.path ?? "none")}`);
     if (Object.keys(check.counts).length) lines.push(`    counts: ${JSON.stringify(check.counts)}`);
     for (const diagnostic of check.diagnostics.slice(0, 5)) lines.push(`    note: ${display(diagnostic)}`);