@reqvire-org/ads 0.3.16 → 0.3.18

package/dist/mcp/mutations.mjs

@@ -15,6 +15,7 @@ import { createCaptureController, captureSelections } from "../capture.mjs";
 import { previewSourceRevision } from "../preview-inputs.mjs";
 import { inspectScenarios } from "../scenarios.mjs";
 import { checkUnitCandidate, checkUnitFiles, inspectUnits, validateUnitId } from "../units.mjs";
+import { acceptance, failure as evidenceFailure } from "../evidence.mjs";
 
 export const mutationLimits = { units: 8, files: 32, patchBytes: 256 * 1024, patchFileBytes: 16 * 1024 * 1024, fileBytes: 16 * 1024 * 1024, readChars: 12000, snapshotFiles: 20000, snapshotBytes: 128 * 1024 * 1024 };
 const digest = bytes => `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
@@ -22,8 +23,8 @@ const ignored = new Set([".git", ".ds", "node_modules", ".vite", "coverage", ".p
 const textFile = file => /\.(?:[cm]?[jt]sx?|css|html|jsonc?|md|txt|svg)$/.test(file);
 const setupDotfile = file => /^\.(?:oxlintrc|linariarc|babelrc)(?:\.json)?$/.test(file);
 
-function fail(rule, message, file) {
-  return Object.assign(new Error(message), { diagnostic: { rule, message, ...(file ? { file } : {}) } });
+function fail(rule, message, file, boundary = evidenceFailure("architecture","mutation-policy",rule)) {
+  return Object.assign(new Error(message), { diagnostic: { rule, message, failure:boundary, ...(file ? { file } : {}) } });
 }
 
 function address(options, file) {
@@ -108,12 +109,13 @@ function snapshot(options, destination) {
   return JSON.stringify(entries);
 }
 
-function checkCommand(command, args, cwd, signal, input) {
+function checkCommand(command, args, cwd, signal, input, gate = {category:"architecture",phase:"patch-preparation"}) {
   return new Promise((resolve, reject) => {
-    if (signal?.aborted) { reject(fail("mutation-cancelled", "Mutation cancelled before validation.")); return; }
+    if (signal?.aborted) { reject(fail("mutation-cancelled", "Mutation cancelled before validation.",undefined,evidenceFailure("runner","mutation-execution","ADS_CANCELLED"))); return; }
     const child = spawn(command, args, { cwd, shell: false, detached: process.platform !== "win32", windowsHide: true, stdio: [input === undefined ? "ignore" : "pipe", "pipe", "pipe"],
       env: { ...process.env, PATH: [path.join(cwd, "node_modules/.bin"), path.dirname(process.execPath), process.env.PATH ?? ""].join(path.delimiter) } });
     let output = "", failure;
+    const startedAt=Date.now();
     if (input !== undefined) { child.stdin.on("error", () => {}); child.stdin.end(input); }
     function kill() {
       if (!child.pid) return;
@@ -130,13 +132,23 @@ function checkCommand(command, args, cwd, signal, input) {
     child.once("exit", kill); // Also clean up descendants of a finished launcher.
     child.once("close", code => {
       clearTimeout(timer); signal?.removeEventListener("abort", abort);
-      if (failure) reject(failure);
-      else if (code !== 0) reject(fail("mutation-check", `${path.basename(command)} ${args.join(" ")} failed (${code}).\n${output}`));
-      else resolve({ command: path.basename(command), args, passed: true });
+      const detail={command:path.basename(command),args,elapsedMs:Date.now()-startedAt,exitCode:code};
+      if (failure || code !== 0) {
+        const error=failure??fail("mutation-check", `${path.basename(command)} ${args.join(" ")} failed (${code}).\n${output}`);
+        error.diagnostic={...(error.diagnostic??{rule:"mutation-check",message:error.message}),...detail,output:output.slice(-4000),failure:evidenceFailure(failure?"runner":gate.category,gate.phase,failure?.code??(failure?"ADS_COMMAND_INTERRUPTED":"ADS_COMMAND_EXIT"),{certainty:"observed-boundary"})};
+        reject(error);
+      } else resolve({ ...detail,phase:gate.phase, passed: true });
     });
   });
 }
 
+function mutationEvidence(result, candidateRevision) {
+  const diagnostics=(result.diagnostics??[]).map(diagnostic=>({...diagnostic,failure:diagnostic.failure??evidenceFailure("architecture","mutation-policy",diagnostic.rule)}));
+  const failed=diagnostics[0];
+  const accepted=acceptance("candidate-validation",result.ok,(result.checks??[]).filter(check=>check.passed&&!check.skipped).map(check=>check.name??[check.command,...(check.args??[])].join(" ")),["unregistered-checks","unselected-behavior-checks","post-application-preview-freshness","visual-parity","accessibility-audit"]);
+  return {...result,...(result.diagnostics?{diagnostics}:{}),acceptance:accepted,investigation:{target:"candidate",candidateRevision:candidateRevision??null,...(failed?{failure:failed.failure,failingStep:failed.failure.phase,source:failed.file?{file:failed.file,line:failed.line,column:failed.column}:null,...(failed.command?{command:failed.command,args:failed.args,exitCode:failed.exitCode,output:failed.output}:{}),message:failed.message}:{}),acceptance:accepted}};
+}
+
 function checks(options) {
   const context = projectContext(options);
   const pkg = JSON.parse(readFileSync(path.join(options.root, "package.json"), "utf8"));
@@ -175,11 +187,12 @@ export function createMutationController(directory, { captures = createCaptureCo
         startLine: source.content.slice(0, offset).split("\n").length };
     },
     async apply({ unit, patch, patchFile, patches, dryRun = false, screenshot = false, captures: selections }, signal, notifyProgress) {
-      if (busy) return { ok: false, applied: false, diagnostics: [{ rule: "mutation-busy", message: "Another mutation is validating; retry after it finishes." }] };
+      if (busy) return mutationEvidence({ ok: false, applied: false, diagnostics: [{ rule: "mutation-busy", message: "Another mutation is validating; retry after it finishes.",failure:evidenceFailure("runner","mutation-execution","ADS_MUTATION_BUSY") }] });
       busy = true;
       active = new AbortController();
       signal = signal ? AbortSignal.any([signal, active.signal]) : active.signal;
-      let temporary;
+      let temporary, candidateRevision;
+      let boundary=evidenceFailure("runner","mutation-execution","ADS_MUTATION_EXCEPTION",{certainty:"unclassified"});
       const verified = [];
       try {
         const options = loadConfig(root);
@@ -264,8 +277,9 @@ export function createMutationController(directory, { captures = createCaptureCo
         const candidateOptions = loadConfig(candidate);
         const extraChecks = checks(candidateOptions);
         const expected = snapshot(candidateOptions);
+        candidateRevision=digest(Buffer.from(expected));
         const result = checkProject(candidate, { trackingRoot: root });
-        if (!result.ok) return lastResult = { ok: false, applied: false, diagnostics: result.diagnostics.slice(0, 50), total: result.diagnostics.length, checks: verified };
+        if (!result.ok) return lastResult = mutationEvidence({ ok: false, applied: false, diagnostics: result.diagnostics, total: result.diagnostics.length, checks: verified },candidateRevision);
         verified.push({ name: "ads check", passed: true });
         const lintConfig = generateLintConfig(candidate).file;
         const require = createRequire(path.join(candidate, "package.json"));
@@ -276,30 +290,33 @@ export function createMutationController(directory, { captures = createCaptureCo
         if (configuration) for (const file of inspectUnits(candidateOptions).units.find(item => item.id === "configuration").files) {
           if (/\.[cm]?[jt]sx?$/.test(file) && !lintPaths.some(directory => isInside(path.resolve(candidate, directory), path.resolve(candidate, file)))) lintPaths.push(file);
         }
-        await checkCommand(process.execPath, [executable, "--deny-warnings", "--config", lintConfig, ...lintPaths], candidate, signal);
+        await checkCommand(process.execPath, [executable, "--deny-warnings", "--config", lintConfig, ...lintPaths], candidate, signal, undefined, {category:"architecture",phase:"registered-oxlint"});
         verified.push({ name: "registered Oxlint rules", passed: true });
         if (assets || configuration) {
+          boundary=evidenceFailure("build","brand-assets","ADS_ASSET_BUILD");
           const brand = await generateBrandAssets(candidate);
           verified.push({ name: "brand assets", passed: true, skipped: !!brand.skipped });
         }
-        for (const check of extraChecks) verified.push(await checkCommand(check.command, check.args, candidate, signal));
+        for (const check of extraChecks) verified.push(await checkCommand(check.command, check.args, candidate, signal, undefined, {category:"build",phase:`project-check:${check.args[1]}`}));
+        boundary=evidenceFailure("runner","behavior-verification","ADS_BEHAVIOR_SETUP");
         const behaviorUnits = affectedBehaviorUnits(candidateOptions, changes.map(change => change.path));
         if (behaviorUnits.length) {
           const verification = createVerificationController(candidate, { reportRoot: root, onProgress: value => { progress = { stage: "behavior", ...value }; notifyProgress?.(progress); } });
           let evidence;
           try { evidence = await verification.run({ units: behaviorUnits, persist: false }, signal); }
           finally { await verification.close(); }
-          if (!evidence.ok) return lastResult = { ok: false, applied: false, diagnostics: [...evidence.diagnostics, ...evidence.results.filter(item => item.status !== "passed").map(item => ({ rule: "behavior-check", message: `${item.unit}#${item.check}: ${item.status}. ${item.message}` }))].slice(0, 50), checks: verified, behavior: evidence };
+          if (!evidence.ok) return lastResult = mutationEvidence({ ok: false, applied: false, diagnostics: [...evidence.results.filter(item => item.status !== "passed").map(item => ({ rule: "behavior-check", failure:item.failure, message: `${item.unit}#${item.check}: ${item.status}. ${item.message}` })),...evidence.diagnostics], checks: verified, behavior: evidence },candidateRevision);
           verified.push({ name: "registered behavior checks", passed: true, results: evidence.results });
         }
         let screenshots;
         if (screenshot) {
+          boundary=evidenceFailure("runner","capture","ADS_CAPTURE_FAILED");
           progress = { stage: "capture", total: selections.length, completed: 0, active: [], profile: "screenshots", elapsedMs: 0 };
           notifyProgress?.(progress);
           const proposal = digest(Buffer.from(JSON.stringify(changes.map(change => [change.path, change.content === null ? null : digest(Buffer.from(change.content))]))));
           screenshots = await captures.run({ captures: selections, candidateRoot: candidate, proposal, publish: false }, signal, value => { progress = value; notifyProgress?.(value); });
         }
-        if (signal?.aborted) throw fail("mutation-cancelled", "Mutation cancelled before application.");
+        if (signal?.aborted) throw fail("mutation-cancelled", "Mutation cancelled before application.",undefined,evidenceFailure("runner","mutation-execution","ADS_CANCELLED"));
         if (snapshot(candidateOptions) !== expected) throw fail("mutation-check", "A validation command changed source files. Use checks without source-writing side effects.");
         if (snapshot(loadConfig(root)) !== before) throw fail("mutation-conflict", "Project inputs changed during validation; no changes were applied. Read current source and retry.");
         for (const change of changes) address(options, change.path);
@@ -336,11 +353,11 @@ export function createMutationController(directory, { captures = createCaptureCo
         const warnings = [];
         if (!dryRun && (assets || configuration)) { try { await generateBrandAssets(root); } catch (error) { warnings.push({ rule: "mutation-assets", message: `Source was applied; generated brand output needs recovery: ${error.message}` }); } }
         if (!dryRun && captures.store.fingerprint()) { try { captures.store.promote(previewSourceRevision(loadConfig(root)), inspectScenarios(loadConfig(root)).scenarios); } catch (error) { warnings.push({ rule: "mutation-capture", message: `Source was applied; capture promotion needs recovery: ${error.message}` }); } }
-        return lastResult = { ok: true, ...(patches ? {units,transaction:true} : {unit}), applied: !dryRun, changes: changes.map(change => ({ path: change.path, operation: change.content === null ? "delete" : change.expectedDigest === null ? "create" : "update", digest: change.content === null ? null : digest(Buffer.from(change.content)) })), checks: verified, ...(result.advisories?.length ? { advisories: result.advisories.slice(0, 50), advisoryCount: result.advisories.length } : {}), ...(warnings.length ? { warnings } : {}),
+        return lastResult = mutationEvidence({ ok: true, ...(patches ? {units,transaction:true} : {unit}), applied: !dryRun, changes: changes.map(change => ({ path: change.path, operation: change.content === null ? "delete" : change.expectedDigest === null ? "create" : "update", digest: change.content === null ? null : digest(Buffer.from(change.content)) })), checks: verified, ...(result.advisories?.length ? { advisories: result.advisories, advisoryCount: result.advisories.length } : {}), ...(warnings.length ? { warnings } : {}),
           ...(screenshots ? { screenshots } : {}),
-          preview: "Source validation passed. Inspect the managed preview build and rendered scenario after applying; validation is not visual verification." };
+          preview: "Source validation passed. Inspect the managed preview build and rendered scenario after applying; validation is not visual verification." },candidateRevision);
       } catch (error) {
-        return lastResult = { ok: false, applied: false, diagnostics: [error.diagnostic ?? { rule: "mutation-error", message: error.message }], checks: verified };
+        return lastResult = mutationEvidence({ ok: false, applied: false, diagnostics: [error.diagnostic ?? { rule: "mutation-error", message: error.message,failure:error.failure??boundary }], checks: verified },candidateRevision);
       } finally { try { if (temporary) rmSync(temporary, { recursive: true, force: true }); } finally { busy = false; active = undefined; progress = undefined; } }
     },
   };