@xenonbyte/da-vinci-workflow 0.2.5 → 0.2.6

package/lib/lint-bindings.js

@@ -1,23 +1,24 @@
 const path = require("path");
-const { STATUS } = require("./workflow-contract");
 const {
   unique,
   resolveImplementationLanding,
-  resolveChangeDir,
   parseBindingsArtifact,
   readChangeArtifacts,
   readArtifactTexts
 } = require("./planning-parsers");
+const { buildGateEnvelope, finalizeGateEnvelope } = require("./gate-utils");
+const {
+  buildBasePlanningResultEnvelope,
+  finalizePlanningResult,
+  resolveChangeWithFindings
+} = require("./planning-quality-utils");
 
 function buildEnvelope(projectRoot, strict) {
   return {
-    status: STATUS.PASS,
-    failures: [],
-    warnings: [],
-    notes: [],
-    projectRoot,
-    changeId: null,
-    strict,
+    ...buildBasePlanningResultEnvelope(projectRoot, strict),
+    gates: {
+      bindingsHealth: null
+    },
     summary: {
       mappings: 0,
       malformed: 0
@@ -29,13 +30,19 @@ function finalize(result) {
   result.failures = unique(result.failures);
   result.warnings = unique(result.warnings);
   result.notes = unique(result.notes);
-  const hasFindings = result.failures.length > 0 || result.warnings.length > 0;
-  if (!hasFindings) {
-    result.status = STATUS.PASS;
-    return result;
+  return finalizePlanningResult(result);
+}
+
+function attachBindingsGateFindings(result, gate) {
+  for (const message of gate.blocking || []) {
+    result.failures.push(`[gate:bindingsHealth] ${message}`);
+  }
+  for (const message of gate.advisory || []) {
+    result.warnings.push(`[gate:bindingsHealth] ${message}`);
+  }
+  for (const message of gate.compatibility || []) {
+    result.notes.push(`[gate:bindingsHealth] ${message}`);
   }
-  result.status = result.strict ? STATUS.BLOCK : STATUS.WARN;
-  return result;
 }
 
 function lintBindings(projectPathInput, options = {}) {
@@ -43,20 +50,22 @@ function lintBindings(projectPathInput, options = {}) {
   const strict = options.strict === true;
   const requestedChangeId = options.changeId ? String(options.changeId).trim() : "";
   const result = buildEnvelope(projectRoot, strict);
+  const bindingsGate = buildGateEnvelope("bindingsHealth");
 
-  const resolved = resolveChangeDir(projectRoot, requestedChangeId);
-  result.failures.push(...resolved.failures);
-  result.notes.push(...resolved.notes);
-  if (!resolved.changeDir) {
+  const changeDir = resolveChangeWithFindings(projectRoot, requestedChangeId, result.failures, result.notes);
+  if (!changeDir) {
+    result.gates.bindingsHealth = finalizeGateEnvelope(bindingsGate, { strict });
     result.notes.push("lint-bindings defaults to advisory mode; pass `--strict` to block on findings.");
     return finalize(result);
   }
-  result.changeId = resolved.changeId;
+  result.changeId = path.basename(changeDir);
 
-  const artifactPaths = readChangeArtifacts(projectRoot, resolved.changeId);
+  const artifactPaths = readChangeArtifacts(projectRoot, result.changeId);
   const artifacts = readArtifactTexts(artifactPaths);
   if (!artifacts.bindings) {
-    result.failures.push("Missing `pencil-bindings.md` for lint-bindings.");
+    bindingsGate.blocking.push("Missing `pencil-bindings.md` for lint-bindings.");
+    result.gates.bindingsHealth = finalizeGateEnvelope(bindingsGate, { strict });
+    attachBindingsGateFindings(result, result.gates.bindingsHealth);
     result.notes.push("lint-bindings defaults to advisory mode; pass `--strict` to block on findings.");
     return finalize(result);
   }
@@ -66,17 +75,19 @@ function lintBindings(projectPathInput, options = {}) {
   result.summary.malformed = parsed.malformed.length;
 
   if (parsed.mappings.length === 0) {
-    result.failures.push("No implementation-to-Pencil mappings were parsed from `pencil-bindings.md`.");
+    bindingsGate.blocking.push(
+      "No implementation-to-Pencil mappings were parsed from `pencil-bindings.md`."
+    );
   }
   if (parsed.malformed.length > 0) {
     for (const malformed of parsed.malformed) {
-      result.warnings.push(`Malformed binding mapping entry: "${malformed}".`);
+      bindingsGate.advisory.push(`Malformed binding mapping entry: "${malformed}".`);
     }
   }
 
   for (const mapping of parsed.mappings) {
     if (!mapping.implementation || !mapping.designPage) {
-      result.warnings.push(`Malformed binding mapping entry: "${mapping.raw}".`);
+      bindingsGate.advisory.push(`Malformed binding mapping entry: "${mapping.raw}".`);
       continue;
     }
 
@@ -86,21 +97,23 @@ function lintBindings(projectPathInput, options = {}) {
         /missing|todo|gap|pending|temporary/i.test(note)
       );
       if (noteContainsIntentionalGap) {
-        result.warnings.push(
+        bindingsGate.compatibility.push(
           `Unresolved implementation landing for "${mapping.implementation}" (allowed by explicit notes).`
         );
       } else {
-        result.warnings.push(`Unresolved implementation landing for "${mapping.implementation}".`);
+        bindingsGate.advisory.push(`Unresolved implementation landing for "${mapping.implementation}".`);
       }
     }
 
     if (mapping.designSource && !String(mapping.designSource).includes(".pen")) {
-      result.warnings.push(
+      bindingsGate.advisory.push(
         `Binding source for "${mapping.implementation}" does not look like a .pen path: "${mapping.designSource}".`
       );
     }
   }
 
+  result.gates.bindingsHealth = finalizeGateEnvelope(bindingsGate, { strict });
+  attachBindingsGateFindings(result, result.gates.bindingsHealth);
   result.notes.push("lint-bindings defaults to advisory mode; pass `--strict` to block on findings.");
   return finalize(result);
 }