madr-lint 0.4.1 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.4.2
+
+### Patch Changes
+
+- [#127](https://github.com/knktkc/madr-lint/pull/127) [`ac0883e`](https://github.com/knktkc/madr-lint/commit/ac0883e1b9c015cf328ea2d4e806c564cc42489f) Thanks [@knktkc](https://github.com/knktkc)! - Bypass gray-matter's content-keyed parse cache ([#122](https://github.com/knktkc/madr-lint/issues/122)). gray-matter 4.0.3 memoizes a parse only when it is called with no options, in a plain object keyed by the *whole document* (`matter.cache[content]`). Both parser call sites now pass a shared, frozen options object, which turns that memoization off.
+  
+  - **A document whose entire content is any `Object.prototype` member name (`constructor`, `toString`, `valueOf`, `__proto__`, …) no longer crashes.** Every one of those twelve lookups hit an inherited member, which gray-matter accepted as a cache hit and returned as a file with `content: undefined` — so `parseFile` threw `TypeError: Cannot convert undefined or null to object` and `frontmatterOffset` threw `TypeError: Cannot read properties of undefined (reading 'length')`. The throw escaped `lintFiles`, so `madr-lint docs/adr` on a directory holding such a file exited with a stack trace instead of reporting; it now reports the file's violations like any other. Only those exact bodies were affected — a trailing newline made the key an ordinary miss.
+  - **madr-lint no longer keeps every parsed document in memory.** The cache retained each document's full content for the process lifetime, as the key, the stripped body, and an `orig` Buffer. Measured over 1,000 distinct 8.4 KB documents: 16.9 MB retained before (8.9 MB heap + 8.0 MB buffers, about 2.1x the corpus), 0 MB now. Per-file lint throughput is unchanged (-1% to +3% across the rule benches, i.e. noise). `--fix` now performs a real second parse in `frontmatterOffset` where it previously got a memo hit — about +3 µs per file per pass, measured on this repo's own ADRs; correctness is unaffected.
+
+- [#134](https://github.com/knktkc/madr-lint/pull/134) [`7512968`](https://github.com/knktkc/madr-lint/commit/7512968fc1420e232bd60cb977b5f7cb091be5aa) Thanks [@knktkc](https://github.com/knktkc)! - Read the fields below a bullet-marker change in a MADR v2 metadata block ([#115](https://github.com/knktkc/madr-lint/issues/115)). `* Status: accepted` followed by `- Date: 2026/07/06` is two CommonMark lists with no node between them, so the HTML-comment bridge added for [#73](https://github.com/knktkc/madr-lint/issues/73) could not reach the second one and every field below the marker change vanished from metadata.
+  
+  - **A marker change no longer drops fields.** An adjacent list now joins the metadata block when *every* one of its items reads as a `Key: value` pair, so the `Date` above is parsed, keeps its own line number, is targetable by `madr-lint-disable-next-line`, and is repaired by `--fix` — instead of degrading a line-suppressible `invalidDate` into an unsuppressible file-level `missingDate`. The gate is shape, not marker: an ordered list (`1. Date: …`) after an unordered one merges on the same terms; a list with any non-`Key: value` item is prose and still ends the block, as do a paragraph, a code fence, a thematic break, a blockquote, a heading of any depth, and visible HTML.
+  - **`extractListMetadata` (public export) returns more keys for some documents.** The accepted cost of a shape-only gate is over-merging: a genuine prose list whose every bullet happens to read `Key: value` (`- Option A: do nothing`) is now merged into the block, so its keys appear in `listMetadata` / `metadata`. Merging can only add keys — duplicates still resolve first-wins, so an earlier field always shadows a later one and no document loses a key it had. The recognized-key gate (`status`, `date`, `deciders`, `decision-makers`, `consulted`, `informed`) is unchanged as a mechanism, but its outcome can change: a document whose only recognized key sits in the adjacent list now returns metadata where it previously returned `null` (which also lets `madr-lint init` cast a v2 version vote for it). Absorbed junk keys on their own never flip that gate.
+  - **Upgrading with a baseline**: a v2 field below a marker change was reported as a file-level `missingDate` / `missingStatus`; it is now reported as `invalidDate` / `invalidStatus` on the field's own line. If you baselined the old entry, re-run `madr-lint --update-baseline` — the stored entry no longer absorbs the new diagnostic, and the file goes red on an otherwise unchanged tree.
+
+- [#135](https://github.com/knktkc/madr-lint/pull/135) [`eba7822`](https://github.com/knktkc/madr-lint/commit/eba78224ea23a018b6d1102c5de4af1a114903ca) Thanks [@knktkc](https://github.com/knktkc)! - Resolve `madr-lint-disable-next-line` from the comment's last line ([#116](https://github.com/knktkc/madr-lint/issues/116)). A directive spelled as a multi-line `<!--` … `-->` block parsed correctly, but the suppression layer counted its target from the html node's **start** line, so it landed on the comment's own interior instead of the content below `-->`. Directives now carry the node's end line and count from there.
+  
+  - **A multi-line directive now reaches the line it points at.** Previously the diagnostic below `-->` was reported despite the directive — for the issue's document (a `disable-next-line madr/date-iso8601` split across three lines between two MADR v2 metadata items), `invalidDate` on the `* Date:` line was reported, not suppressed. A blank line between `-->` and the content is skipped, exactly as it is for a one-line directive.
+  - **Single-line directives are unchanged**: a one-line comment's end line *is* its start line, so nothing about the existing spelling moves. `disable` / `enable` ranges still open and close at the comment's **start** line, which is what preserves their pre-existing behavior. That choice is observable: an inline multi-line comment shares its start line with the content beside it — `[gone](./nope.md) <!--` … `-->` spans three lines while `madr/no-broken-links` reports the link on the first — so counting a range from the end line would stop such a `disable` from covering its own line.
+  - **The docs no longer ask you to keep a directive on one line.** The suppression guide (en/ja) and the `adopt-madr-lint` / `new-adr` skills previously called the multi-line spelling a miss; they now document it as working.
+
+- [#123](https://github.com/knktkc/madr-lint/pull/123) [`657e3ef`](https://github.com/knktkc/madr-lint/commit/657e3ef7ab641fc8055796d22c8303a2b931b4b0) Thanks [@knktkc](https://github.com/knktkc)! - Make filename- and document-derived record keys prototype-safe ([#56](https://github.com/knktkc/madr-lint/issues/56)). Both the cache manifest and the MADR v2 metadata parser accumulated untrusted keys on plain objects, where a key that names an `Object.prototype` member is read and written *through* the prototype instead of stored as data.
+  
+  - **Cache manifest keys are now prototype-safe.** `manifest.files` is a null-prototype map on both the cold path and rehydration, so a file whose relative path is `__proto__` caches, serializes, and cache-hits like any other. Previously the write went through the inherited `__proto__` setter — the entry never reached `manifest.json` and every run was a cold miss. No user-facing bug is fixed: the key is unreachable from the CLI (`findAdrFiles` drops every non-`.md` target, and a `__proto__.md` file keys as `__proto__.md`) and from the published API (`lintFiles` is not exported from `madr-lint`). This is hardening for the internal `lintFiles` seam and any future entry point that passes explicit paths. It was never a global pollution vector either: plain assignment swapped that one record's prototype rather than mutating `Object.prototype`. `saveManifest` output is byte-identical for ordinary keys, so existing manifests stay valid — no `CACHE_SCHEMA_VERSION` bump.
+  - **A v2 body-list key named `constructor` is now read.** The leading metadata block de-duplicates with `Object.hasOwn` instead of `in`, so `* Constructor: x` lands in `metadata.constructor` (with its body position and value offset) rather than being silently skipped because `'constructor' in {}` is true through inheritance. `constructor` is the only reachable case: key normalization lowercases, so `toString` arrives as `tostring` (not a member), and `__proto__` never matches the key pattern, which requires a leading letter. No rule reads these fields — the fix is for library consumers of `extractListMetadata` and `ParsedFile`, which previously got `Object` back for such a key. The returned records keep an ordinary prototype, so `hasOwnProperty` still works on them.
+  - **A frontmatter key named `__proto__` survives the v2 merge.** When a file carries both YAML frontmatter and a v2 body list, the merge step that drops explicit `null`/`undefined` now builds its record on a null prototype, so `__proto__: x` reaches `metadata.__proto__` as data instead of being swallowed by the inherited setter. The merged `metadata` is still a plain object.
+
 ## 0.4.1
 
 ### Patch Changes

package/dist/cli.js

@@ -130,11 +130,19 @@ import { join as join2, resolve as resolve2 } from "path";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { toString } from "mdast-util-to-string";
 import grayMatter from "gray-matter";
+
+// src/core/null-proto-map.ts
+function nullProtoMap() {
+  return /* @__PURE__ */ Object.create(null);
+}
+
+// src/core/parser.ts
+var GRAY_MATTER_OPTIONS = Object.freeze({});
 function frontmatterOffset(content) {
-  return content.length - grayMatter(content).content.length;
+  return content.length - grayMatter(content, GRAY_MATTER_OPTIONS).content.length;
 }
 function parseFile(content) {
-  const matter = grayMatter(content);
+  const matter = grayMatter(content, GRAY_MATTER_OPTIONS);
   const data = matter.data;
   const frontmatter = Object.keys(data).length > 0 ? data : null;
   const ast = fromMarkdown(matter.content);
@@ -144,7 +152,7 @@ function parseFile(content) {
   let metadataLoc = listResult && Object.keys(listResult.loc).length > 0 ? { ...listResult.loc } : null;
   let metadataValueLoc = listResult && Object.keys(listResult.valueOffsets).length > 0 ? { ...listResult.valueOffsets } : null;
   if (frontmatter && listMetadata) {
-    const frontmatterDefined = {};
+    const frontmatterDefined = nullProtoMap();
     for (const [k, v] of Object.entries(frontmatter)) {
       if (v !== null && v !== void 0) frontmatterDefined[k] = v;
     }
@@ -211,7 +219,7 @@ function extractListMetadataWithLoc(ast, body) {
       bridged = true;
       continue;
     }
-    if (child.type === "list" && bridged) {
+    if (child.type === "list" && (bridged || child.children.length > 0 && child.children.every((item) => extractListItemKV(item)))) {
       segments.push(child);
       bridged = false;
       continue;
@@ -219,13 +227,13 @@ function extractListMetadataWithLoc(ast, body) {
     break;
   }
   if (segments.length === 0) return null;
-  const values = {};
-  const loc = {};
-  const valueOffsets = {};
+  const values = nullProtoMap();
+  const loc = nullProtoMap();
+  const valueOffsets = nullProtoMap();
   for (const list of segments) {
     for (const item of list.children) {
       const pair = extractListItemKV(item);
-      if (pair && !(pair.key in values)) {
+      if (pair && !Object.hasOwn(values, pair.key)) {
         values[pair.key] = pair.value;
         const start = item.position?.start;
         if (start) loc[pair.key] = { line: start.line, column: start.column };
@@ -238,7 +246,7 @@ function extractListMetadataWithLoc(ast, body) {
   const hasRecognizedKey = Object.keys(values).some(
     (k) => RECOGNIZED_METADATA_KEYS.has(k)
   );
-  return hasRecognizedKey ? { values, loc, valueOffsets } : null;
+  return hasRecognizedKey ? { values: { ...values }, loc, valueOffsets } : null;
 }
 var KEY_PATTERN = /^[A-Za-z][A-Za-z0-9 \-_]*$/;
 var SEPARATOR_PATTERN = /^\s*:\s*/;
@@ -445,9 +453,6 @@ var BASELINE_DISPLAY_PATH = ".madr-lint/baseline.json";
 function baselinePath(cwd) {
   return join3(cwd, ".madr-lint", "baseline.json");
 }
-function nullProtoMap() {
-  return /* @__PURE__ */ Object.create(null);
-}
 function buildBaseline(diagnostics) {
   const entries = nullProtoMap();
   for (const d of diagnostics) {
@@ -605,7 +610,13 @@ function loadManifest(path) {
     ) {
       return null;
     }
-    return data;
+    const files = nullProtoMap();
+    for (const [key, entry] of Object.entries(
+      data.files
+    )) {
+      files[key] = entry;
+    }
+    return { ...data, files };
   } catch {
     return null;
   }
@@ -812,7 +823,7 @@ var DIRECTIVE_KINDS = /* @__PURE__ */ new Set([
   "disable-next-line"
 ]);
 var DIRECTIVE_PREFIX = "madr-lint-";
-function parseDirective(value, line) {
+function parseDirective(value, line, endLine) {
   const trimmed = value.trim();
   if (!trimmed.startsWith("<!--") || !trimmed.endsWith("-->")) return null;
   const inner = trimmed.slice(4, -3).trim();
@@ -823,7 +834,12 @@ function parseDirective(value, line) {
   const keyword = wsIndex === -1 ? afterPrefix : afterPrefix.slice(0, wsIndex);
   if (!DIRECTIVE_KINDS.has(keyword)) return null;
   const rest = wsIndex === -1 ? "" : afterPrefix.slice(wsIndex);
-  return { kind: keyword, rules: parseRuleList(rest), line };
+  return {
+    kind: keyword,
+    rules: parseRuleList(rest),
+    line,
+    endLine
+  };
 }
 function parseRuleList(rest) {
   const trimmed = rest.trim();
@@ -834,8 +850,9 @@ function parseRuleList(rest) {
 function walkHtml(node, out) {
   if (node.type === "html") {
     const line = node.position?.start.line;
-    if (typeof line === "number") {
-      const directive = parseDirective(node.value, line);
+    const endLine = node.position?.end.line;
+    if (typeof line === "number" && typeof endLine === "number") {
+      const directive = parseDirective(node.value, line, endLine);
       if (directive) out.push(directive);
     }
   }
@@ -874,7 +891,7 @@ function collectDirectives(ast, body) {
         break;
       }
       case "disable-next-line": {
-        const target = nextNonBlankLine(directive.line);
+        const target = nextNonBlankLine(directive.endLine);
         if (target === null) break;
         let entry = index.nextLine.get(target);
         if (!entry) {
@@ -1186,7 +1203,7 @@ function lintFiles(opts) {
         schemaVersion: CACHE_SCHEMA_VERSION,
         version: opts.cache.pkgVersion,
         configHash: opts.cache.configHash,
-        files: {}
+        files: nullProtoMap()
       };
     }
   }