madr-lint 0.1.0

package/dist/index.js

@@ -0,0 +1,975 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/runner.ts
+import Ajv from "ajv";
+
+// src/core/parser.ts
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { toString } from "mdast-util-to-string";
+import grayMatter from "gray-matter";
+function parseFile(content) {
+  const matter = grayMatter(content);
+  const data = matter.data;
+  const frontmatter = Object.keys(data).length > 0 ? data : null;
+  const ast = fromMarkdown(matter.content);
+  const listMetadata = extractListMetadata(ast);
+  let metadata = null;
+  if (frontmatter && listMetadata) {
+    const frontmatterDefined = {};
+    for (const [k, v] of Object.entries(frontmatter)) {
+      if (v !== null && v !== void 0) frontmatterDefined[k] = v;
+    }
+    metadata = { ...listMetadata, ...frontmatterDefined };
+  } else if (frontmatter) {
+    metadata = frontmatter;
+  } else if (listMetadata) {
+    metadata = listMetadata;
+  }
+  return { frontmatter, listMetadata, metadata, ast, body: matter.content };
+}
+var RECOGNIZED_METADATA_KEYS = /* @__PURE__ */ new Set([
+  "status",
+  "date",
+  "deciders",
+  "decision-makers",
+  "consulted",
+  "informed"
+]);
+function extractListMetadata(ast) {
+  let firstList = null;
+  for (const child of ast.children) {
+    if (child.type === "heading") {
+      if (child.depth >= 2) break;
+      continue;
+    }
+    if (child.type === "html") continue;
+    if (child.type === "list") {
+      firstList = child;
+      break;
+    }
+    break;
+  }
+  if (!firstList) return null;
+  const result = {};
+  for (const item of firstList.children) {
+    const pair = extractListItemKV(item);
+    if (pair && !(pair.key in result)) {
+      result[pair.key] = pair.value;
+    }
+  }
+  const hasRecognizedKey = Object.keys(result).some(
+    (k) => RECOGNIZED_METADATA_KEYS.has(k)
+  );
+  return hasRecognizedKey ? result : null;
+}
+var KEY_PATTERN = /^[A-Za-z][A-Za-z0-9 \-_]*$/;
+var SEPARATOR_PATTERN = /^\s*:\s*/;
+function normalizeKey(rawKey) {
+  return rawKey.trim().toLowerCase().replace(/\s+/g, "-");
+}
+function extractListItemKV(item) {
+  const para = item.children[0];
+  if (para?.type !== "paragraph") return null;
+  const paragraph = para;
+  const first = paragraph.children[0];
+  if (!first) return null;
+  if (first.type === "strong") {
+    const keyNode = first.children[0];
+    if (keyNode?.type !== "text" || !KEY_PATTERN.test(keyNode.value)) {
+      return null;
+    }
+    const sep = paragraph.children[1];
+    if (sep?.type !== "text" || !SEPARATOR_PATTERN.test(sep.value)) return null;
+    const valueHead = sep.value.replace(SEPARATOR_PATTERN, "");
+    const valueTail = paragraph.children.slice(2).map((n) => toString(n)).join("");
+    const value = (valueHead + valueTail).trim();
+    if (value === "") return null;
+    return { key: normalizeKey(keyNode.value), value };
+  }
+  if (first.type === "text") {
+    const colonIdx = first.value.indexOf(":");
+    if (colonIdx === -1) return null;
+    const rawKey = first.value.slice(0, colonIdx);
+    if (!KEY_PATTERN.test(rawKey)) return null;
+    const valueHead = first.value.slice(colonIdx + 1).replace(/^\s+/, "");
+    const valueTail = paragraph.children.slice(1).map((n) => toString(n)).join("");
+    const value = (valueHead + valueTail).trim();
+    if (value === "") return null;
+    return { key: normalizeKey(rawKey), value };
+  }
+  return null;
+}
+
+// src/core/runner.ts
+var ajv = new Ajv({ strict: true, allErrors: true });
+var validatorCache = /* @__PURE__ */ new WeakMap();
+function getValidator(schema) {
+  let validator = validatorCache.get(schema);
+  if (!validator) {
+    validator = ajv.compile(schema);
+    validatorCache.set(schema, validator);
+  }
+  return validator;
+}
+var INTERNAL_ERROR_RULE_NAME = "core/internal-error";
+var RuleOptionsError = class extends Error {
+  constructor(ruleName, ajvErrors) {
+    super(`Invalid options for rule ${ruleName}: ${ajvErrors}`);
+    this.ruleName = ruleName;
+    this.ajvErrors = ajvErrors;
+    this.name = "RuleOptionsError";
+  }
+  ruleName;
+  ajvErrors;
+};
+function runRule(rule9, file, runtime = {}) {
+  return runRulesOnFile([rule9], file, runtime);
+}
+function runRulesOnFile(rules, file, runtime = {}) {
+  const diagnostics = [];
+  const severity = runtime.severity ?? "error";
+  let parsed = null;
+  const ensureParsed = () => {
+    parsed ??= parseFile(file.content);
+    return parsed;
+  };
+  const enterMap = {};
+  const exitMap = {};
+  let hasASTRule = false;
+  for (const rule9 of rules) {
+    const perRuleOptions = runtime.optionsByRule?.[rule9.meta.name] ?? runtime.options;
+    const mergedOptions = {
+      ...rule9.meta.defaultOptions,
+      ...perRuleOptions
+    };
+    if (rule9.meta.schema && !runtime.skipValidation) {
+      const validator = getValidator(rule9.meta.schema);
+      if (!validator(mergedOptions)) {
+        throw new RuleOptionsError(rule9.meta.name, ajv.errorsText(validator.errors));
+      }
+    }
+    const context = {
+      file,
+      get frontmatter() {
+        return ensureParsed().frontmatter;
+      },
+      get metadata() {
+        return ensureParsed().metadata;
+      },
+      options: mergedOptions,
+      report(d) {
+        diagnostics.push({
+          ruleName: rule9.meta.name,
+          severity,
+          path: file.path,
+          ...d
+        });
+      }
+    };
+    let listeners;
+    try {
+      listeners = rule9.create(context);
+    } catch (err) {
+      if (err instanceof RuleOptionsError) throw err;
+      diagnostics.push(
+        internalErrorDiagnostic(rule9.meta.name, "create", err, file.path)
+      );
+      continue;
+    }
+    if (listeners) {
+      hasASTRule = true;
+      collectListeners(rule9, listeners, enterMap, exitMap, diagnostics, file);
+    }
+  }
+  if (hasASTRule) {
+    walk(ensureParsed().ast, enterMap, exitMap);
+  }
+  return diagnostics;
+}
+function internalErrorDiagnostic(ruleName, operation, err, path) {
+  return {
+    ruleName: INTERNAL_ERROR_RULE_NAME,
+    messageId: "ruleThrew",
+    severity: "error",
+    path,
+    data: {
+      rule: ruleName,
+      operation,
+      error: err instanceof Error ? err.message : String(err)
+    }
+  };
+}
+function collectListeners(rule9, listeners, enterMap, exitMap, diagnostics, file) {
+  const wrap = (op) => (handler) => (node) => {
+    try {
+      handler(node);
+    } catch (err) {
+      diagnostics.push(
+        internalErrorDiagnostic(rule9.meta.name, op, err, file.path)
+      );
+    }
+  };
+  if (listeners.enter) {
+    const wrapEnter = wrap("enter");
+    for (const [type, handler] of Object.entries(listeners.enter)) {
+      if (handler) (enterMap[type] ??= []).push(wrapEnter(handler));
+    }
+  }
+  if (listeners.exit) {
+    const wrapExit = wrap("exit");
+    for (const [type, handler] of Object.entries(listeners.exit)) {
+      if (handler) (exitMap[type] ??= []).push(wrapExit(handler));
+    }
+  }
+}
+function walk(node, enterMap, exitMap) {
+  const enterHandlers = enterMap[node.type];
+  if (enterHandlers) {
+    for (const handler of enterHandlers) handler(node);
+  }
+  if ("children" in node && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      walk(child, enterMap, exitMap);
+    }
+  }
+  const exitHandlers = exitMap[node.type];
+  if (exitHandlers) {
+    for (const handler of exitHandlers) handler(node);
+  }
+}
+function buildProjectFile(file) {
+  const parsed = parseFile(file.content);
+  return {
+    path: file.path,
+    content: file.content,
+    frontmatter: parsed.frontmatter,
+    metadata: parsed.metadata,
+    ast: parsed.ast
+  };
+}
+function runRulesOnProject(rules, files, runtime = {}) {
+  const diagnostics = [];
+  const severity = runtime.severity ?? "error";
+  for (const rule9 of rules) {
+    const perRuleOptions = runtime.optionsByRule?.[rule9.meta.name] ?? runtime.options;
+    const mergedOptions = {
+      ...rule9.meta.defaultOptions,
+      ...perRuleOptions
+    };
+    if (rule9.meta.schema && !runtime.skipValidation) {
+      const validator = getValidator(rule9.meta.schema);
+      if (!validator(mergedOptions)) {
+        throw new RuleOptionsError(
+          rule9.meta.name,
+          ajv.errorsText(validator.errors)
+        );
+      }
+    }
+    const context = {
+      files,
+      options: mergedOptions,
+      fileExists: runtime.fileExists,
+      report(d) {
+        diagnostics.push({
+          ruleName: rule9.meta.name,
+          severity,
+          ...d
+        });
+      }
+    };
+    try {
+      rule9.check(context);
+    } catch (err) {
+      diagnostics.push(
+        internalErrorDiagnostic(rule9.meta.name, "check", err, "<project>")
+      );
+    }
+  }
+  return diagnostics;
+}
+
+// src/core/types.ts
+function isProjectRule(rule9) {
+  return "check" in rule9;
+}
+
+// src/rules/index.ts
+var rules_exports = {};
+__export(rules_exports, {
+  dateIso8601: () => date_iso8601_default,
+  filenameFormat: () => filename_format_default,
+  noBrokenLinks: () => no_broken_links_default,
+  noDuplicateNumbering: () => no_duplicate_numbering_default,
+  noNumberingGap: () => no_numbering_gap_default,
+  requiredSections: () => required_sections_default,
+  statusEnum: () => status_enum_default,
+  supersedesBidirectional: () => supersedes_bidirectional_default
+});
+
+// src/rules/date-iso8601/schema.json
+var schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    field: {
+      type: "string",
+      description: "Frontmatter key to read. Default: 'date'."
+    }
+  }
+};
+
+// src/rules/date-iso8601/index.ts
+function normalizeDate(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) return null;
+    return value.toISOString().slice(0, 10);
+  }
+  return null;
+}
+function isValidIso8601Date(s) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(s)) return false;
+  const parts = s.split("-").map(Number);
+  const [year, month, day] = parts;
+  if (year === void 0 || month === void 0 || day === void 0) return false;
+  const d = new Date(Date.UTC(year, month - 1, day));
+  return d.getUTCFullYear() === year && d.getUTCMonth() === month - 1 && d.getUTCDate() === day;
+}
+var rule = {
+  meta: {
+    name: "madr/date-iso8601",
+    type: "perFile",
+    versionCompat: ["v2", "v3", "v4"],
+    docs: {
+      description: "Validate that ADR `date` (frontmatter or v2 bold-list) is a valid ISO 8601 calendar date (YYYY-MM-DD)",
+      url: "https://github.com/knktkc/madr-lint/blob/main/docs/rules/date-iso8601.md",
+      recommended: true
+    },
+    messages: {
+      missingDate: 'Metadata does not contain a "{{field}}" field (checked frontmatter and v2 bold-list)',
+      invalidDate: 'Date "{{date}}" is not a valid ISO 8601 calendar date (YYYY-MM-DD)'
+    },
+    defaultOptions: {
+      field: "date"
+    },
+    schema: schema_default
+  },
+  create(context) {
+    const meta = context.metadata;
+    const fieldName = context.options.field;
+    if (!meta) {
+      context.report({
+        messageId: "missingDate",
+        data: { field: fieldName }
+      });
+      return;
+    }
+    const raw = meta[fieldName];
+    const dateStr = normalizeDate(raw);
+    if (dateStr === null) {
+      context.report({
+        messageId: "missingDate",
+        data: { field: fieldName }
+      });
+      return;
+    }
+    if (!isValidIso8601Date(dateStr)) {
+      context.report({
+        messageId: "invalidDate",
+        data: { date: dateStr }
+      });
+    }
+  }
+};
+var date_iso8601_default = rule;
+
+// src/rules/filename-format/index.ts
+import { basename } from "path";
+
+// src/core/regex-safety.ts
+import safeRegex from "safe-regex2";
+var SAFE_REGEX_LIMIT = 25;
+var cache = /* @__PURE__ */ new Map();
+function assertSafeRegex(pattern, ruleName, optionPath) {
+  const cached = cache.get(pattern);
+  if (cached) return cached;
+  let regex;
+  try {
+    regex = new RegExp(pattern);
+  } catch (err) {
+    throw new RuleOptionsError(
+      ruleName,
+      `option "${optionPath}" is not a valid regular expression: ${err.message}`
+    );
+  }
+  if (!safeRegex(regex, { limit: SAFE_REGEX_LIMIT })) {
+    throw new RuleOptionsError(
+      ruleName,
+      `option "${optionPath}" (${pattern}) appears unsafe (catastrophic backtracking). Reject before runtime.`
+    );
+  }
+  cache.set(pattern, regex);
+  return regex;
+}
+
+// src/rules/filename-format/schema.json
+var schema_default2 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    pattern: {
+      type: "string",
+      description: "Regex (as string) the basename must match. Defaults to ^[0-9]{4}-[a-z0-9-]+\\.md$"
+    }
+  }
+};
+
+// src/rules/filename-format/index.ts
+var rule2 = {
+  meta: {
+    name: "madr/filename-format",
+    type: "perFile",
+    versionCompat: ["v2", "v3", "v4"],
+    docs: {
+      description: "Enforce ADR filename convention NNNN-kebab-case.md",
+      url: "https://github.com/knktkc/madr-lint/blob/main/docs/rules/filename-format.md",
+      recommended: true
+    },
+    messages: {
+      invalidFilename: 'Filename "{{filename}}" does not match expected pattern "{{expected}}"'
+    },
+    defaultOptions: {
+      pattern: "^[0-9]{4}-[a-z0-9-]+\\.md$"
+    },
+    schema: schema_default2
+  },
+  create(context) {
+    const { pattern } = context.options;
+    const regex = assertSafeRegex(pattern, "madr/filename-format", "pattern");
+    const filename = basename(context.file.path);
+    if (!regex.test(filename)) {
+      context.report({
+        messageId: "invalidFilename",
+        data: { filename, expected: pattern }
+      });
+    }
+  }
+};
+var filename_format_default = rule2;
+
+// src/rules/no-broken-links/index.ts
+import { dirname, posix } from "path";
+
+// src/rules/no-broken-links/schema.json
+var schema_default3 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  additionalProperties: false,
+  properties: {}
+};
+
+// src/rules/no-broken-links/index.ts
+var PROTOCOL_REGEX = /^[a-z][a-z0-9+.-]*:/i;
+function isLinkNode(node) {
+  return node.type === "link" && "url" in node && typeof node.url === "string";
+}
+function isExternalOrAnchor(url) {
+  if (url === "" || url.startsWith("#")) return true;
+  return PROTOCOL_REGEX.test(url);
+}
+function stripAnchorAndQuery(url) {
+  const hash = url.indexOf("#");
+  const query = url.indexOf("?");
+  let cut = hash;
+  if (query !== -1 && (cut === -1 || query < cut)) cut = query;
+  return cut === -1 ? url : url.slice(0, cut);
+}
+function safeDecode(path) {
+  if (!path.includes("%")) return path;
+  try {
+    return decodeURIComponent(path);
+  } catch {
+    return path;
+  }
+}
+function resolveRelative(fromDir, url) {
+  if (url.startsWith("/")) return url.slice(1);
+  return posix.normalize(posix.join(fromDir, url));
+}
+function collectLinks(node, out) {
+  if (isLinkNode(node)) out.push(node);
+  if ("children" in node && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      collectLinks(child, out);
+    }
+  }
+}
+var rule3 = {
+  meta: {
+    name: "madr/no-broken-links",
+    type: "project",
+    versionCompat: ["v2", "v3", "v4"],
+    docs: {
+      description: "Relative-path Markdown links must resolve to an existing file in the project",
+      url: "https://github.com/knktkc/madr-lint/blob/main/docs/rules/no-broken-links.md",
+      recommended: true
+    },
+    messages: {
+      brokenLink: 'Link to "{{url}}" resolves to "{{resolvedPath}}", which does not exist in the project'
+    },
+    defaultOptions: {},
+    schema: schema_default3
+  },
+  check(context) {
+    const knownPaths = /* @__PURE__ */ new Set();
+    for (const file of context.files) {
+      knownPaths.add(file.path);
+    }
+    for (const file of context.files) {
+      const links = [];
+      collectLinks(file.ast, links);
+      for (const link of links) {
+        const url = link.url;
+        if (isExternalOrAnchor(url)) continue;
+        const pathOnly = safeDecode(stripAnchorAndQuery(url));
+        if (pathOnly === "") continue;
+        const fileDir = dirname(file.path);
+        const resolvedPath = resolveRelative(fileDir, pathOnly);
+        const exists = knownPaths.has(resolvedPath) || (context.fileExists?.(resolvedPath) ?? false);
+        if (!exists) {
+          context.report({
+            messageId: "brokenLink",
+            path: file.path,
+            data: { url, resolvedPath }
+          });
+        }
+      }
+    }
+  }
+};
+var no_broken_links_default = rule3;
+
+// src/rules/no-duplicate-numbering/index.ts
+import { basename as basename2 } from "path";
+
+// src/rules/no-duplicate-numbering/schema.json
+var schema_default4 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  additionalProperties: false,
+  properties: {}
+};
+
+// src/rules/no-duplicate-numbering/index.ts
+var NUMBER_REGEX = /^(\d{4})-/;
+var rule4 = {
+  meta: {
+    name: "madr/no-duplicate-numbering",
+    type: "project",
+    versionCompat: ["v2", "v3", "v4"],
+    docs: {
+      description: "No two ADRs share the same NNNN- number prefix",
+      url: "https://github.com/knktkc/madr-lint/blob/main/docs/rules/no-duplicate-numbering.md",
+      recommended: true
+    },
+    messages: {
+      duplicateNumber: "ADR number {{number}} is used by multiple files: {{paths}}"
+    },
+    defaultOptions: {},
+    schema: schema_default4
+  },
+  check(context) {
+    const byNumber = /* @__PURE__ */ new Map();
+    for (const file of context.files) {
+      const match = NUMBER_REGEX.exec(basename2(file.path));
+      if (!match) continue;
+      const number = match[1];
+      if (number === void 0) continue;
+      const group = byNumber.get(number) ?? [];
+      group.push(file.path);
+      byNumber.set(number, group);
+    }
+    for (const [number, paths] of byNumber) {
+      if (paths.length > 1) {
+        const pathList = paths.join(", ");
+        for (const path of paths) {
+          context.report({
+            messageId: "duplicateNumber",
+            path,
+            data: { number, paths: pathList }
+          });
+        }
+      }
+    }
+  }
+};
+var no_duplicate_numbering_default = rule4;
+
+// src/rules/no-numbering-gap/index.ts
+import { basename as basename3 } from "path";
+
+// src/rules/no-numbering-gap/schema.json
+var schema_default5 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  additionalProperties: false,
+  properties: {}
+};
+
+// src/rules/no-numbering-gap/index.ts
+var NUMBER_REGEX2 = /^(\d{4})-/;
+function format4(n) {
+  return n.toString().padStart(4, "0");
+}
+var rule5 = {
+  meta: {
+    name: "madr/no-numbering-gap",
+    type: "project",
+    versionCompat: ["v2", "v3", "v4"],
+    docs: {
+      description: "Detect gaps in ADR numbering (e.g. 0001 and 0003 exist but 0002 is missing). Convention-only; default off.",
+      url: "https://github.com/knktkc/madr-lint/blob/main/docs/rules/no-numbering-gap.md",
+      recommended: false
+    },
+    messages: {
+      numberingGap: "Numbering gap: missing {{missing}} between ADR-{{from}} and ADR-{{to}}"
+    },
+    defaultOptions: {},
+    schema: schema_default5
+  },
+  check(context) {
+    const numberToPath = /* @__PURE__ */ new Map();
+    for (const file of context.files) {
+      const match = NUMBER_REGEX2.exec(basename3(file.path));
+      if (!match?.[1]) continue;
+      const n = Number.parseInt(match[1], 10);
+      if (!Number.isNaN(n)) numberToPath.set(n, file.path);
+    }
+    if (numberToPath.size < 2) return;
+    const sortedNumbers = Array.from(numberToPath.keys()).toSorted(
+      (a, b) => a - b
+    );
+    for (let i = 1; i < sortedNumbers.length; i++) {
+      const prev = sortedNumbers[i - 1];
+      const curr = sortedNumbers[i];
+      if (prev === void 0 || curr === void 0) continue;
+      if (curr === prev + 1) continue;
+      const missingNumbers = [];
+      for (let n = prev + 1; n < curr; n++) {
+        missingNumbers.push(format4(n));
+      }
+      const currPath = numberToPath.get(curr);
+      if (!currPath) continue;
+      context.report({
+        messageId: "numberingGap",
+        path: currPath,
+        data: {
+          from: format4(prev),
+          to: format4(curr),
+          missing: missingNumbers.join(", ")
+        }
+      });
+    }
+  }
+};
+var no_numbering_gap_default = rule5;
+
+// src/rules/required-sections/index.ts
+import { toString as toString2 } from "mdast-util-to-string";
+
+// src/rules/required-sections/schema.json
+var schema_default6 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    sections: {
+      type: "array",
+      items: { type: "string" },
+      description: "Required heading texts. Order does not matter."
+    },
+    matchMode: {
+      type: "string",
+      enum: ["exact", "startsWith"],
+      description: "Comparison mode against heading text."
+    }
+  }
+};
+
+// src/rules/required-sections/index.ts
+var rule6 = {
+  meta: {
+    name: "madr/required-sections",
+    type: "perFile",
+    versionCompat: ["v2", "v3", "v4"],
+    docs: {
+      description: "Enforce that ADRs contain required heading sections",
+      url: "https://github.com/knktkc/madr-lint/blob/main/docs/rules/required-sections.md",
+      recommended: true
+    },
+    messages: {
+      missingSection: 'Missing required section: "{{section}}"'
+    },
+    defaultOptions: {
+      sections: [
+        "Context and Problem Statement",
+        "Decision Outcome",
+        "Consequences"
+      ],
+      matchMode: "exact"
+    },
+    schema: schema_default6
+  },
+  create(context) {
+    const seen = [];
+    return {
+      enter: {
+        heading(node) {
+          if (node.type !== "heading") return;
+          seen.push(toString2(node).trim());
+        }
+      },
+      exit: {
+        root() {
+          const { sections, matchMode } = context.options;
+          for (const section of sections) {
+            const matched = seen.some(
+              (heading) => matchMode === "startsWith" ? heading.startsWith(section) : heading === section
+            );
+            if (!matched) {
+              context.report({
+                messageId: "missingSection",
+                data: { section, found: [...seen] }
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+var required_sections_default = rule6;
+
+// src/rules/status-enum/schema.json
+var schema_default7 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    values: {
+      type: "array",
+      items: { type: "string" },
+      description: "Exact-match allowed status values."
+    },
+    prefixValues: {
+      type: "array",
+      items: { type: "string" },
+      description: "startsWith-match allowed prefixes (e.g. 'superseded by')."
+    },
+    caseSensitive: {
+      type: "boolean",
+      description: "When false, comparisons are case-insensitive."
+    }
+  }
+};
+
+// src/rules/status-enum/index.ts
+var rule7 = {
+  meta: {
+    name: "madr/status-enum",
+    type: "perFile",
+    versionCompat: ["v2", "v3", "v4"],
+    docs: {
+      description: "Validate that ADR `status` (frontmatter or v2 bold-list) is in the allowed enum",
+      url: "https://github.com/knktkc/madr-lint/blob/main/docs/rules/status-enum.md",
+      recommended: true
+    },
+    messages: {
+      missingStatus: 'Metadata does not contain a "status" field (checked frontmatter and v2 bold-list)',
+      invalidStatus: 'Status "{{status}}" is not one of: {{allowed}}'
+    },
+    defaultOptions: {
+      values: ["proposed", "rejected", "accepted", "deprecated"],
+      prefixValues: ["superseded by"],
+      caseSensitive: false
+    },
+    schema: schema_default7
+  },
+  create(context) {
+    const meta = context.metadata;
+    if (!meta || typeof meta.status !== "string") {
+      context.report({ messageId: "missingStatus", data: {} });
+      return;
+    }
+    const { values, prefixValues, caseSensitive } = context.options;
+    const status = meta.status;
+    const compareStatus = caseSensitive ? status : status.toLowerCase();
+    const compareValues = caseSensitive ? values : values.map((v) => v.toLowerCase());
+    const comparePrefixes = caseSensitive ? prefixValues : prefixValues.map((p) => p.toLowerCase());
+    const exactMatch = compareValues.includes(compareStatus);
+    const prefixMatch = comparePrefixes.some(
+      (p) => compareStatus.startsWith(p)
+    );
+    if (!exactMatch && !prefixMatch) {
+      const allowed = [
+        ...values,
+        ...prefixValues.map((p) => `${p} ...`)
+      ];
+      context.report({
+        messageId: "invalidStatus",
+        data: { status, allowed }
+      });
+    }
+  }
+};
+var status_enum_default = rule7;
+
+// src/rules/supersedes-bidirectional/index.ts
+import { basename as basename4 } from "path";
+
+// src/rules/supersedes-bidirectional/schema.json
+var schema_default8 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  additionalProperties: false,
+  properties: {}
+};
+
+// src/rules/supersedes-bidirectional/index.ts
+var ADR_NUMBER_REGEX = /^(\d{4})-/;
+var FORWARD_FIELD = "supersedes";
+var BACKWARD_FIELD = "superseded-by";
+function extractAdrNumber(path) {
+  const match = ADR_NUMBER_REGEX.exec(basename4(path));
+  return match?.[1] ?? null;
+}
+function normalizeRefs(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) {
+    return value.filter((v) => typeof v === "string");
+  }
+  return [];
+}
+var rule8 = {
+  meta: {
+    name: "madr/supersedes-bidirectional",
+    type: "project",
+    versionCompat: ["v3", "v4"],
+    docs: {
+      description: "Frontmatter `supersedes` and `superseded-by` must reference each other bidirectionally",
+      url: "https://github.com/knktkc/madr-lint/blob/main/docs/rules/supersedes-bidirectional.md",
+      recommended: true
+    },
+    messages: {
+      unknownReference: "Frontmatter `{{direction}}: {{ref}}` references an ADR that does not exist",
+      missingBackReference: "`{{source}}` declares `{{direction}}: {{ref}}`, but `{{ref}}` (this file) does not back-reference it via `{{expected}}`"
+    },
+    defaultOptions: {},
+    schema: schema_default8
+  },
+  check(context) {
+    const adrIndex = /* @__PURE__ */ new Map();
+    for (const file of context.files) {
+      const num = extractAdrNumber(file.path);
+      if (num) adrIndex.set(`ADR-${num}`, file);
+    }
+    for (const file of context.files) {
+      const fm = file.frontmatter;
+      if (!fm) continue;
+      const fileNumber = extractAdrNumber(file.path);
+      if (!fileNumber) continue;
+      const fileRef = `ADR-${fileNumber}`;
+      const forwardRefs = normalizeRefs(fm[FORWARD_FIELD]);
+      const backwardRefs = normalizeRefs(fm[BACKWARD_FIELD]);
+      for (const ref of forwardRefs) {
+        const target = adrIndex.get(ref);
+        if (!target) {
+          context.report({
+            messageId: "unknownReference",
+            path: file.path,
+            data: { ref, direction: FORWARD_FIELD }
+          });
+          continue;
+        }
+        const targetBack = normalizeRefs(target.frontmatter?.[BACKWARD_FIELD]);
+        if (!targetBack.includes(fileRef)) {
+          context.report({
+            messageId: "missingBackReference",
+            path: target.path,
+            data: {
+              ref,
+              source: file.path,
+              direction: BACKWARD_FIELD,
+              expected: fileRef
+            }
+          });
+        }
+      }
+      for (const ref of backwardRefs) {
+        const target = adrIndex.get(ref);
+        if (!target) {
+          context.report({
+            messageId: "unknownReference",
+            path: file.path,
+            data: { ref, direction: BACKWARD_FIELD }
+          });
+          continue;
+        }
+        const targetFwd = normalizeRefs(target.frontmatter?.[FORWARD_FIELD]);
+        if (!targetFwd.includes(fileRef)) {
+          context.report({
+            messageId: "missingBackReference",
+            path: target.path,
+            data: {
+              ref,
+              source: file.path,
+              direction: FORWARD_FIELD,
+              expected: fileRef
+            }
+          });
+        }
+      }
+    }
+  }
+};
+var supersedes_bidirectional_default = rule8;
+
+// src/configs/recommended.ts
+var recommended = {
+  "madr/date-iso8601": "error",
+  "madr/filename-format": "error",
+  "madr/no-broken-links": "error",
+  "madr/no-duplicate-numbering": "error",
+  // Convention-only — opt in if your team treats ADR numbering as a
+  // contiguous sequence. See docs/rules/no-numbering-gap.md.
+  "madr/no-numbering-gap": "off",
+  "madr/required-sections": "error",
+  "madr/status-enum": "error",
+  "madr/supersedes-bidirectional": "error"
+};
+
+// src/index.ts
+function defineConfig(config) {
+  return config;
+}
+export {
+  INTERNAL_ERROR_RULE_NAME,
+  RuleOptionsError,
+  buildProjectFile,
+  defineConfig,
+  extractListMetadata,
+  isProjectRule,
+  parseFile,
+  recommended,
+  rules_exports as rules,
+  runRule,
+  runRulesOnFile,
+  runRulesOnProject
+};
+//# sourceMappingURL=index.js.map