@chrisdudek/yg 5.4.2 → 5.5.1

package/dist/structure.d.ts

@@ -491,6 +491,14 @@ declare class SuppressMarkerError extends Error {
     file: string;
     line: number;
     readonly code = "SUPPRESS_MARKER_MISSING_REASON";
+    /**
+     * Self-describing what/why/next for the malformed marker. A reasonless marker
+     * is a fault in the SOURCE file's marker — NOT in the aspect's check.mjs — so
+     * the deterministic runners re-surface this as its own diagnostic instead of an
+     * `aspect-check-runtime-error`. (The LLM-sizing paths build their own message
+     * from `file`/`line`; only the deterministic consumers read `messageData`.)
+     */
+    readonly messageData: IssueMessage;
     constructor(message: string, file: string, line: number);
 }
 

package/dist/structure.js

@@ -164,6 +164,26 @@ var UndeclaredGraphReadError = class extends Error {
   }
   nodePath;
 };
+function makeGraphFile(repoRelPosixPath, content, bytes, recorder, subjectFiles) {
+  if (!recorder || subjectFiles?.has(repoRelPosixPath)) {
+    return { path: repoRelPosixPath, content };
+  }
+  const rec = recorder;
+  let recorded = false;
+  const file = { path: repoRelPosixPath };
+  Object.defineProperty(file, "content", {
+    enumerable: true,
+    configurable: true,
+    get() {
+      if (!recorded) {
+        rec.recordRead(repoRelPosixPath, bytes);
+        recorded = true;
+      }
+      return content;
+    }
+  });
+  return file;
+}
 function computeAllowedNodePaths(currentPath, graph) {
   const allowed = /* @__PURE__ */ new Set([currentPath]);
   const current = graph.nodes.get(currentPath);
@@ -225,11 +245,8 @@ function createCtxGraph(params) {
         if (stat2.isFile()) {
           const bytes = fs2.readFileSync(abs);
           const content = bytes.toString("utf8");
-          files.push({ path: p, content });
           touchedFiles.push(p);
-          if (recorder && !subjectFiles?.has(p)) {
-            recorder.recordRead(p, bytes);
-          }
+          files.push(makeGraphFile(p, content, bytes, recorder, subjectFiles));
         }
       } catch {
       }
@@ -734,45 +751,96 @@ var SuppressMarkerError = class extends Error {
     this.file = file;
     this.line = line;
     this.name = "SuppressMarkerError";
+    const loc = `${toPosixPath(file)}:${line}`;
+    this.messageData = {
+      what: `Malformed yg-suppress marker at ${loc} \u2014 it is missing the required reason after the aspect id.`,
+      why: `A single-line or disable marker must carry a reason after its closing parenthesis; a reasonless marker cannot be honored. This is a fault in the source file's marker, not in the aspect's check.`,
+      next: `Add a reason to the marker at ${loc}, or remove it.`
+    };
   }
   file;
   line;
   code = "SUPPRESS_MARKER_MISSING_REASON";
+  /**
+   * Self-describing what/why/next for the malformed marker. A reasonless marker
+   * is a fault in the SOURCE file's marker — NOT in the aspect's check.mjs — so
+   * the deterministic runners re-surface this as its own diagnostic instead of an
+   * `aspect-check-runtime-error`. (The LLM-sizing paths build their own message
+   * from `file`/`line`; only the deterministic consumers read `messageData`.)
+   */
+  messageData;
 };
-var RE_SINGLE = /\byg-suppress\(\s*([^)]+?)\s*\)\s*(.+)?$/m;
-var RE_DISABLE = /\byg-suppress-disable\(\s*([^)]+?)\s*\)\s*(.+)?$/m;
-var RE_ENABLE = /\byg-suppress-enable\(\s*([^)]+?)\s*\)/;
-function commentBody(text) {
-  if (text.startsWith("//")) return text.slice(2).trim();
-  if (text.startsWith("/*")) return text.replace(/^\/\*+/, "").replace(/\*+\/$/, "").trim();
-  return text.trim();
+var LEADER_DELIM = String.raw`\/\/[/!]*|\/\*+|\*+|#+|--+|;+|<!--|\{-|\(\*|[!%'"]`;
+var RE_LEADER_OPTIONAL = new RegExp(String.raw`^\s*(${LEADER_DELIM})?\s*`);
+var RE_LEADER_REQUIRED = new RegExp(String.raw`^\s*(${LEADER_DELIM})\s*`);
+var RE_MARKER = /^yg-suppress(-disable|-enable)?\(\s*([^)]*?)\s*\)\s*(.*)$/;
+var RE_ASPECT_ID = /^(?:\*|[A-Za-z0-9_][A-Za-z0-9_./-]*)$/;
+var RE_ANY_CLOSER = /\s*(?:\*+\/|-->|-\}|\*\))\s*$/;
+var RE_CLOSER_CSTYLE = /\s*\*+\/\s*$/;
+var RE_CLOSER_HTML = /\s*-->\s*$/;
+var RE_CLOSER_HASKELL = /\s*-\}\s*$/;
+var RE_CLOSER_OCAML = /\s*\*\)\s*$/;
+function stripCloser(reason, leader) {
+  if (leader === void 0) return reason.replace(RE_ANY_CLOSER, "");
+  if (leader.startsWith("//")) return reason;
+  if (leader.startsWith("/*") || /^\*+$/.test(leader)) return reason.replace(RE_CLOSER_CSTYLE, "");
+  if (leader === "<!--") return reason.replace(RE_CLOSER_HTML, "");
+  if (leader === "{-") return reason.replace(RE_CLOSER_HASKELL, "");
+  if (leader === "(*") return reason.replace(RE_CLOSER_OCAML, "");
+  return reason;
 }
 function splitAspectList(raw) {
   return raw.split(",").map((s) => s.trim()).filter(Boolean);
 }
-function makeMarker(kind, match, line, file) {
-  const aspectIds = splitAspectList(match[1]);
-  const reason = (match[2] ?? "").trim();
-  if (reason === "") {
+function matchMarkerLine(line, requireDelimiter) {
+  if (line.endsWith("\r")) line = line.slice(0, -1);
+  const leader = (requireDelimiter ? RE_LEADER_REQUIRED : RE_LEADER_OPTIONAL).exec(line);
+  if (leader === null) return null;
+  const m = RE_MARKER.exec(line.slice(leader[0].length));
+  if (m === null) return null;
+  const aspectIds = splitAspectList(m[2]);
+  if (aspectIds.length === 0) return null;
+  if (!aspectIds.every((id) => RE_ASPECT_ID.test(id))) return null;
+  const kind = m[1] === "-disable" ? "disable" : m[1] === "-enable" ? "enable" : "single";
+  const reason = kind === "enable" ? "" : stripCloser(m[3], leader[1]).trim();
+  return { kind, aspectIds, reason };
+}
+function parseMarker(lineText, line, file, requireDelimiter) {
+  const m = matchMarkerLine(lineText, requireDelimiter);
+  if (m === null) return null;
+  if (m.kind !== "enable" && m.reason === "") {
     throw new SuppressMarkerError(
-      `yg-suppress${kind === "disable" ? "-disable" : ""}(${match[1]}) missing reason at ${file}:${line}`,
+      `yg-suppress${m.kind === "disable" ? "-disable" : ""}(${m.aspectIds.join(", ")}) missing reason at ${file}:${line}`,
       file,
       line
     );
   }
-  return { kind, aspectIds, reason, line };
+  return { kind: m.kind, aspectIds: m.aspectIds, reason: m.reason, line };
 }
-function parseMarker(commentText, line, file) {
-  const body = commentBody(commentText);
-  let m = body.match(RE_DISABLE);
-  if (m) return makeMarker("disable", m, line, file);
-  m = body.match(RE_ENABLE);
-  if (m) {
-    return { kind: "enable", aspectIds: splitAspectList(m[1]), reason: "", line };
-  }
-  m = body.match(RE_SINGLE);
-  if (m) return makeMarker("single", m, line, file);
-  return null;
+var RE_FENCE = /^ {0,3}((?:`{3,})|(?:~{3,}))[ \t]*(.*)$/;
+var MARKDOWN_EXTS = /* @__PURE__ */ new Set([".md", ".markdown"]);
+function isMarkdownExt(file) {
+  return MARKDOWN_EXTS.has(extname3(file).toLowerCase());
+}
+function markdownFencedLines(text) {
+  const fenced = /* @__PURE__ */ new Set();
+  const lines = text.split("\n");
+  let open = null;
+  for (let i = 0; i < lines.length; i++) {
+    const m = RE_FENCE.exec(lines[i]);
+    if (open === null) {
+      if (m) {
+        open = { char: m[1][0], len: m[1].length };
+        fenced.add(i + 1);
+      }
+      continue;
+    }
+    fenced.add(i + 1);
+    if (m && m[1][0] === open.char && m[1].length >= open.len && m[2].trim() === "") {
+      open = null;
+    }
+  }
+  return fenced;
 }
 function collectSuppressions(tree, file, totalLines, content) {
   const hasGrammar = getLanguageForExtension(extname3(file)) !== null;
@@ -780,13 +848,18 @@ function collectSuppressions(tree, file, totalLines, content) {
   if (hasGrammar && tree) {
     const comments = findComments({ path: file, ast: tree });
     for (const c of comments) {
-      const m = parseMarker(c.text, c.startPosition.row + 1, file);
-      if (m) markers.push(m);
+      const commentLines = c.text.split("\n");
+      for (let i = 0; i < commentLines.length; i++) {
+        const m = parseMarker(commentLines[i], c.startPosition.row + i + 1, file, false);
+        if (m) markers.push(m);
+      }
     }
   } else if (content !== void 0) {
     const lines = content.split("\n");
+    const fenced = isMarkdownExt(file) ? markdownFencedLines(content) : null;
     for (let i = 0; i < lines.length; i++) {
-      const m = parseMarker(lines[i], i + 1, file);
+      if (fenced && fenced.has(i + 1)) continue;
+      const m = parseMarker(lines[i], i + 1, file, true);
       if (m) markers.push(m);
     }
   } else {
@@ -812,22 +885,26 @@ function collectSuppressions(tree, file, totalLines, content) {
       for (const id of m.aspectIds) {
         if (id === "*") {
           if (openWildcard !== null) {
-            ranges.push({ aspectIds: /* @__PURE__ */ new Set(["*"]), startLine: openWildcard, endLine: m.line - 1, isWildcard: true });
+            if (m.line - 1 >= openWildcard) {
+              ranges.push({ aspectIds: /* @__PURE__ */ new Set(["*"]), startLine: openWildcard, endLine: m.line - 1, isWildcard: true });
+            }
             openWildcard = null;
           }
         } else {
           const start = openSpecific.get(id);
           if (start !== void 0) {
-            ranges.push({ aspectIds: /* @__PURE__ */ new Set([id]), startLine: start, endLine: m.line - 1, isWildcard: false });
+            if (m.line - 1 >= start) {
+              ranges.push({ aspectIds: /* @__PURE__ */ new Set([id]), startLine: start, endLine: m.line - 1, isWildcard: false });
+            }
             openSpecific.delete(id);
           }
         }
       }
     }
   }
-  if (openWildcard !== null) ranges.push({ aspectIds: /* @__PURE__ */ new Set(["*"]), startLine: openWildcard, endLine: totalLines, isWildcard: true });
+  if (openWildcard !== null && openWildcard <= totalLines) ranges.push({ aspectIds: /* @__PURE__ */ new Set(["*"]), startLine: openWildcard, endLine: totalLines, isWildcard: true });
   for (const [id, start] of openSpecific) {
-    ranges.push({ aspectIds: /* @__PURE__ */ new Set([id]), startLine: start, endLine: totalLines, isWildcard: false });
+    if (start <= totalLines) ranges.push({ aspectIds: /* @__PURE__ */ new Set([id]), startLine: start, endLine: totalLines, isWildcard: false });
   }
   return ranges;
 }
@@ -838,7 +915,7 @@ function isLineSuppressed(ranges, aspectId, line) {
   });
 }
 function formatSuppressedRangesForAspect(ranges, aspectId) {
-  return ranges.filter((r) => r.isWildcard || r.aspectIds.has(aspectId)).map((r) => ({ startLine: r.startLine, endLine: r.endLine })).sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
+  return ranges.filter((r) => r.isWildcard || r.aspectIds.has(aspectId)).filter((r) => r.startLine <= r.endLine).map((r) => ({ startLine: r.startLine, endLine: r.endLine })).sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
 }
 
 // src/utils/validate-check-module.ts
@@ -1458,6 +1535,7 @@ async function buildUnitCtx(params) {
 }
 
 // src/structure/runner.ts
+var SUPPRESS_MARKER_MALFORMED_CODE = "STRUCTURE_SUPPRESS_MARKER_MALFORMED";
 async function runStructureAspect(params) {
   const { aspectDir, aspectId, nodePath, graph, projectRoot, subjectScope } = params;
   const ownCache = !params.parseCache;
@@ -1469,11 +1547,18 @@ async function runStructureAspect(params) {
       if (existing !== void 0) return existing;
       const cached = astCache.get(filePath);
       let ranges;
-      if (cached) {
-        ranges = collectSuppressions(cached.ast, filePath, cached.content.split("\n").length, cached.content);
-      } else {
-        const content = contentByPath.get(filePath);
-        ranges = content !== void 0 ? collectSuppressions(void 0, filePath, content.split("\n").length, content) : null;
+      try {
+        if (cached) {
+          ranges = collectSuppressions(cached.ast, filePath, cached.content.split("\n").length, cached.content);
+        } else {
+          const content = contentByPath.get(filePath);
+          ranges = content !== void 0 ? collectSuppressions(void 0, filePath, content.split("\n").length, content) : null;
+        }
+      } catch (err) {
+        if (err instanceof SuppressMarkerError) {
+          throw new StructureRunnerError(SUPPRESS_MARKER_MALFORMED_CODE, err.messageData);
+        }
+        throw err;
       }
       rangesByFile.set(filePath, ranges);
       return ranges;

package/dist/templates/portal/js/export.js

@@ -62,7 +62,7 @@
     var rows = [['metric', 'value']];
     var keys = [
       'nodes', 'aspects', 'flows', 'pairsTotal', 'pairsLLM', 'pairsDet',
-      'verified', 'refused', 'advisoryRefused', 'unverified', 'noRule', 'draft', 'notApplicable',
+      'verified', 'verifiedDet', 'verifiedLlm', 'refused', 'advisoryRefused', 'unverified', 'noRule', 'draft', 'notApplicable',
       'suppressed', 'coveredFiles', 'uncoveredFiles', 'totalFiles', 'errors', 'warnings',
     ];
     for (var i = 0; i < keys.length; i += 1) rows.push([keys[i], c[keys[i]]]);

package/dist/templates/portal/js/views/coverage-view.js

@@ -75,8 +75,11 @@
 
     // The bar is sized by the real pair STATES (verified / refused / unverified), never by the
     // expected-pair kind totals — a verified segment must be exactly as wide as the verified
-    // count, so an unverified pair can never paint green. The verified label states the LLM-vs-
-    // deterministic makeup of the expected universe honestly without faking a verified split.
+    // count, so an unverified pair can never paint green. The verified label states BOTH the
+    // LLM-vs-deterministic makeup of the expected universe AND the real split of the verified
+    // count itself (verifiedDet / verifiedLlm — tallied off the identical pairs loop `yg check`
+    // uses for its own header), so a green bar can never hide how many pairs were machine-checked
+    // for free vs actually reviewed by an LLM.
     // Advisory refusals are a real expected-pair state, but per the honesty model they render
     // as a NON-BLOCKING warning, never a blocking `refused`. They get their own warning-coloured
     // segment + key so the bar still accounts for every expected pair without ever showing an
@@ -96,7 +99,12 @@
     ledger.appendChild(bar);
 
     var labels = dom.el('div', 'cov-barlabels');
-    labels.appendChild(key('verified', c.verified, 'of ' + c.pairsLLM + ' LLM + ' + c.pairsDet + ' deterministic expected'));
+    labels.appendChild(key(
+      'verified',
+      c.verified,
+      'of ' + c.pairsLLM + ' LLM + ' + c.pairsDet + ' deterministic expected'
+        + ' (' + (c.verifiedDet || 0) + ' deterministic, ' + (c.verifiedLlm || 0) + ' LLM verified)',
+    ));
     labels.appendChild(key('refused', c.refused, 'enforced — blocks (== yg check)'));
     if (advisoryRefused > 0) labels.appendChild(key('warning', advisoryRefused, 'advisory refusal — does not block'));
     labels.appendChild(key('unverified', c.unverified));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrisdudek/yg",
-  "version": "5.4.2",
+  "version": "5.5.1",
   "description": "Architecture rules your AI coding agent can't ignore. It gets the rules for a file before it edits, and every change is checked — by a free local script or an LLM reviewer — before it moves on. Works with Claude Code, Cursor, Copilot, Codex, Cline.",
   "type": "module",
   "bin": {
@@ -25,8 +25,8 @@
     "test:external": "vitest run --config vitest.external.config.ts",
     "test:coverage": "vitest run --coverage",
     "test:e2e:portal": "playwright test",
-    "lint": "eslint src/",
-    "lint:fix": "eslint src/ --fix",
+    "lint": "eslint src/ tests/",
+    "lint:fix": "eslint src/ tests/ --fix",
     "format": "prettier --write \"src/**/*.ts\"",
     "typecheck": "tsc -p tsconfig.check.json",
     "typecheck:e2e": "tsc -p tests/portal-e2e/tsconfig.json"