madr-lint 0.1.0

package/dist/cli.js

@@ -0,0 +1,1500 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cli.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+import { defineCommand, runMain } from "citty";
+
+// src/core/cache.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+function computeContentHash(content) {
+  return createHash("sha1").update(content, "utf8").digest("hex");
+}
+function computeConfigHash(config) {
+  return createHash("sha1").update(stableStringify(config), "utf8").digest("hex");
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map(stableStringify).join(",") + "]";
+  }
+  const entries = Object.entries(value).toSorted(
+    ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+  );
+  return "{" + entries.map(([k, v]) => JSON.stringify(k) + ":" + stableStringify(v)).join(",") + "}";
+}
+function manifestPath(cacheDir) {
+  return join(cacheDir, "manifest.json");
+}
+function loadManifest(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const data = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof data.version !== "string" || typeof data.configHash !== "string" || typeof data.files !== "object" || data.files === null) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function saveManifest(path, manifest) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(manifest), "utf8");
+}
+
+// src/core/config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve } from "path";
+import { createJiti } from "jiti";
+
+// 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/core/config.ts
+var CONFIG_FILES = [
+  ".madrlintrc.json",
+  ".madrlintrc.ts",
+  ".madrlintrc.mts",
+  ".madrlintrc.js",
+  ".madrlintrc.mjs",
+  ".madrlintrc.cjs",
+  "madr-lint.config.ts",
+  "madr-lint.config.mts",
+  "madr-lint.config.js",
+  "madr-lint.config.mjs",
+  "madr-lint.config.cjs"
+];
+function loadConfig(cwd) {
+  for (const name of CONFIG_FILES) {
+    const path = resolve(cwd, name);
+    if (!existsSync2(path)) continue;
+    if (name.endsWith(".json")) {
+      const parsed = JSON.parse(readFileSync2(path, "utf8"));
+      return resolveExtends(parsed);
+    }
+    const jiti = createJiti(import.meta.url, { interopDefault: true });
+    const loaded = jiti(path);
+    const config = typeof loaded === "object" && loaded !== null && "default" in loaded ? loaded.default : loaded;
+    return resolveExtends(config);
+  }
+  return resolveExtends({});
+}
+function resolveExtends(config) {
+  const baseRules = config.extends?.includes(
+    "madr-lint:recommended"
+  ) ? { ...recommended } : {};
+  return {
+    adrDir: config.adrDir ?? "docs/adr",
+    rules: { ...baseRules, ...config.rules },
+    ignorePatterns: config.ignorePatterns ?? [],
+    madrVersion: config.madrVersion ?? "auto",
+    cache: config.cache ?? true,
+    cacheLocation: config.cacheLocation ?? ".madr-lint/cache"
+  };
+}
+
+// src/core/discover.ts
+import { existsSync as existsSync3, readdirSync, statSync } from "fs";
+import { join as join2 } from "path";
+function findAdrFiles(target) {
+  if (!existsSync3(target)) return [];
+  const stat = statSync(target);
+  if (stat.isFile()) {
+    return target.endsWith(".md") ? [target] : [];
+  }
+  if (!stat.isDirectory()) return [];
+  const entries = readdirSync(target, { recursive: true, withFileTypes: true });
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => join2(e.parentPath, e.name)).toSorted();
+}
+
+// src/core/ignore.ts
+import { basename } from "path";
+import picomatch from "picomatch";
+function shouldIgnore(relativePath, patterns) {
+  if (patterns.length === 0) return false;
+  const base = basename(relativePath);
+  for (const pattern of patterns) {
+    if (matchesPattern(relativePath, base, pattern)) return true;
+  }
+  return false;
+}
+function matchesPattern(relativePath, base, pattern) {
+  if (relativePath === pattern) return true;
+  const matcher = picomatch(pattern, { dot: true });
+  if (matcher(relativePath)) return true;
+  if (matcher(base)) return true;
+  if (pattern.includes("/") && !pattern.startsWith("**/")) {
+    const suffixMatcher = picomatch(`**/${pattern}`, { dot: true });
+    if (suffixMatcher(relativePath)) return true;
+  }
+  return false;
+}
+
+// src/core/lint.ts
+import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { isAbsolute, relative, resolve as resolve2, sep } from "path";
+
+// 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 sep3 = paragraph.children[1];
+    if (sep3?.type !== "text" || !SEPARATOR_PATTERN.test(sep3.value)) return null;
+    const valueHead = sep3.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 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/core/lint.ts
+function toPosix(p) {
+  if (sep === "/") return p;
+  return p.split(sep).join("/");
+}
+function lintFiles(opts) {
+  const allDiagnostics = [];
+  const fileEntries = opts.files.map((absolutePath) => ({
+    relativePath: toPosix(relative(opts.cwd, absolutePath)),
+    content: readFileSync3(absolutePath, "utf8")
+  }));
+  const perFileRules = [];
+  const projectRules = [];
+  for (const rule9 of opts.rules) {
+    if (isProjectRule(rule9)) projectRules.push(rule9);
+    else perFileRules.push(rule9);
+  }
+  const optionsByRule = extractOptionsByRule(opts.ruleSeverity);
+  let manifest = null;
+  let filesFromCache = 0;
+  if (opts.cache) {
+    const path = manifestPath(opts.cache.dir);
+    const loaded = loadManifest(path);
+    if (loaded && loaded.version === opts.cache.pkgVersion && loaded.configHash === opts.cache.configHash) {
+      manifest = loaded;
+    } else {
+      manifest = {
+        version: opts.cache.pkgVersion,
+        configHash: opts.cache.configHash,
+        files: {}
+      };
+    }
+  }
+  for (const file of fileEntries) {
+    if (manifest) {
+      const contentHash = computeContentHash(file.content);
+      const entry = manifest.files[file.relativePath];
+      if (entry && entry.contentHash === contentHash) {
+        allDiagnostics.push(...entry.perFileDiagnostics);
+        filesFromCache++;
+        continue;
+      }
+      const fileDiagnostics = runPerFileRulesForFile(
+        perFileRules,
+        opts.ruleSeverity,
+        optionsByRule,
+        file
+      );
+      allDiagnostics.push(...fileDiagnostics);
+      const next = {
+        contentHash,
+        perFileDiagnostics: fileDiagnostics
+      };
+      manifest.files[file.relativePath] = next;
+    } else {
+      allDiagnostics.push(
+        ...runPerFileRulesForFile(
+          perFileRules,
+          opts.ruleSeverity,
+          optionsByRule,
+          file
+        )
+      );
+    }
+  }
+  const enabledProjectRules = projectRules.filter(
+    (rule9) => resolveSeverity(opts.ruleSeverity[rule9.meta.name]) !== "off"
+  );
+  if (enabledProjectRules.length > 0) {
+    const projectFiles = fileEntries.map(
+      (f) => buildProjectFile({ path: f.relativePath, content: f.content })
+    );
+    const projectRoot = resolve2(opts.cwd);
+    const existsCache = /* @__PURE__ */ new Map();
+    const fileExists = (resolvedPath) => {
+      const cached = existsCache.get(resolvedPath);
+      if (cached !== void 0) return cached;
+      const abs = resolve2(projectRoot, resolvedPath);
+      const rel = relative(projectRoot, abs);
+      const escapesRoot = rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel);
+      let result;
+      if (escapesRoot) {
+        result = false;
+      } else {
+        try {
+          result = statSync2(abs, { throwIfNoEntry: false })?.isFile() ?? false;
+        } catch {
+          result = false;
+        }
+      }
+      existsCache.set(resolvedPath, result);
+      return result;
+    };
+    const errorRules = [];
+    const warnRules = [];
+    for (const rule9 of enabledProjectRules) {
+      const sev = resolveSeverity(opts.ruleSeverity[rule9.meta.name]);
+      if (sev === "error") errorRules.push(rule9);
+      else if (sev === "warn") warnRules.push(rule9);
+    }
+    if (errorRules.length > 0) {
+      allDiagnostics.push(
+        ...runRulesOnProject(errorRules, projectFiles, {
+          severity: "error",
+          fileExists,
+          optionsByRule
+        })
+      );
+    }
+    if (warnRules.length > 0) {
+      allDiagnostics.push(
+        ...runRulesOnProject(warnRules, projectFiles, {
+          severity: "warn",
+          fileExists,
+          optionsByRule
+        })
+      );
+    }
+  }
+  if (manifest && opts.cache) {
+    saveManifest(manifestPath(opts.cache.dir), manifest);
+  }
+  return {
+    filesChecked: opts.files.length,
+    filesFromCache,
+    diagnostics: allDiagnostics
+  };
+}
+function runPerFileRulesForFile(perFileRules, ruleSeverity, optionsByRule, file) {
+  const fileContext = {
+    content: file.content,
+    path: file.relativePath
+  };
+  const errorRules = [];
+  const warnRules = [];
+  for (const rule9 of perFileRules) {
+    const sev = resolveSeverity(ruleSeverity[rule9.meta.name]);
+    if (sev === "off") continue;
+    if (sev === "error") errorRules.push(rule9);
+    else warnRules.push(rule9);
+  }
+  const diagnostics = [];
+  if (errorRules.length > 0) {
+    diagnostics.push(
+      ...runRulesOnFile(errorRules, fileContext, {
+        severity: "error",
+        optionsByRule
+      })
+    );
+  }
+  if (warnRules.length > 0) {
+    diagnostics.push(
+      ...runRulesOnFile(warnRules, fileContext, {
+        severity: "warn",
+        optionsByRule
+      })
+    );
+  }
+  return diagnostics;
+}
+function resolveSeverity(config) {
+  if (config === void 0) return "off";
+  if (typeof config === "string") return config;
+  return config[0];
+}
+function extractOptionsByRule(ruleSeverity) {
+  const map = {};
+  for (const [name, config] of Object.entries(ruleSeverity)) {
+    if (Array.isArray(config) && config[1]) map[name] = config[1];
+  }
+  return map;
+}
+
+// src/core/reporter.ts
+import pc from "picocolors";
+var textReporter = {
+  format(diagnostics, rulesByName) {
+    if (diagnostics.length === 0) {
+      return pc.green("\u2713 All clear.");
+    }
+    const byFile = groupByFile(diagnostics);
+    const lines = [];
+    for (const [file, fileDiagnostics] of byFile) {
+      lines.push(pc.underline(file));
+      for (const d of fileDiagnostics) {
+        const sev = d.severity === "error" ? pc.red("  error  ") : pc.yellow("  warn   ");
+        const ruleId = pc.dim(d.ruleName.padEnd(28));
+        const message = renderMessage(d, rulesByName);
+        lines.push(`${sev}${ruleId}  ${message}`);
+      }
+      lines.push("");
+    }
+    const errors = diagnostics.filter((d) => d.severity === "error").length;
+    const warnings = diagnostics.filter((d) => d.severity === "warn").length;
+    lines.push(pc.bold(formatSummary(errors, warnings)));
+    return lines.join("\n");
+  }
+};
+function groupByFile(diagnostics) {
+  const map = /* @__PURE__ */ new Map();
+  for (const d of diagnostics) {
+    if (!map.has(d.path)) map.set(d.path, []);
+    map.get(d.path)?.push(d);
+  }
+  return map;
+}
+function renderMessage(d, rulesByName) {
+  const rule9 = rulesByName.get(d.ruleName);
+  const template = rule9?.meta.messages[d.messageId] ?? d.messageId;
+  return interpolate(template, d.data ?? {});
+}
+function interpolate(template, data) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    const v = data[key];
+    return v !== void 0 ? String(v) : `{{${key}}}`;
+  });
+}
+function formatSummary(errors, warnings) {
+  const parts = [];
+  if (errors > 0) parts.push(`${errors} ${errors === 1 ? "error" : "errors"}`);
+  if (warnings > 0) parts.push(`${warnings} ${warnings === 1 ? "warning" : "warnings"}`);
+  return parts.join(", ");
+}
+var jsonReporter = {
+  format(diagnostics, rulesByName) {
+    const errors = diagnostics.filter((d) => d.severity === "error").length;
+    const warnings = diagnostics.filter((d) => d.severity === "warn").length;
+    const payload = {
+      version: 1,
+      summary: {
+        total: diagnostics.length,
+        errors,
+        warnings
+      },
+      results: diagnostics.map((d) => ({
+        path: d.path,
+        ruleName: d.ruleName,
+        messageId: d.messageId,
+        severity: d.severity,
+        message: renderMessage(d, rulesByName),
+        data: d.data ?? {}
+      }))
+    };
+    return JSON.stringify(payload, null, 2);
+  }
+};
+var sarifReporter = {
+  format(diagnostics, rulesByName) {
+    const ruleNames = [...new Set(diagnostics.map((d) => d.ruleName))];
+    const ruleIndex = new Map(ruleNames.map((name, i) => [name, i]));
+    const sarifRules = ruleNames.map((name) => {
+      const rule9 = rulesByName.get(name);
+      return {
+        id: name,
+        name: name.replace(/[^A-Za-z0-9]/g, "_"),
+        shortDescription: { text: rule9?.meta.docs.description ?? name },
+        helpUri: rule9?.meta.docs.url
+      };
+    });
+    const sarifResults = diagnostics.map((d) => ({
+      ruleId: d.ruleName,
+      ruleIndex: ruleIndex.get(d.ruleName) ?? 0,
+      level: d.severity === "error" ? "error" : "warning",
+      message: { text: renderMessage(d, rulesByName) },
+      locations: [
+        {
+          physicalLocation: {
+            artifactLocation: { uri: d.path, uriBaseId: "%SRCROOT%" },
+            region: { startLine: 1 }
+          }
+        }
+      ]
+    }));
+    const sarif = {
+      $schema: "https://schemastore.azurewebsites.net/schemas/json/sarif-2.1.0.json",
+      version: "2.1.0",
+      runs: [
+        {
+          tool: {
+            driver: {
+              name: "madr-lint",
+              informationUri: "https://github.com/knktkc/madr-lint",
+              rules: sarifRules
+            }
+          },
+          results: sarifResults
+        }
+      ]
+    };
+    return JSON.stringify(sarif, null, 2);
+  }
+};
+var reporters = {
+  text: textReporter,
+  json: jsonReporter,
+  sarif: sarifReporter
+};
+
+// 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 as basename2 } 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 = basename2(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 as dirname2, 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 = dirname2(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 basename3 } 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(basename3(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 basename4 } 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(basename4(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 basename5 } 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(basename5(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/cli.ts
+function toPosix2(p) {
+  if (sep2 === "/") return p;
+  return p.split(sep2).join("/");
+}
+var pkg = JSON.parse(
+  readFileSync4(new URL("../package.json", import.meta.url), "utf8")
+);
+var main = defineCommand({
+  meta: {
+    name: "madr-lint",
+    version: pkg.version,
+    description: "A linter for MADR (Markdown Architectural Decision Records)"
+  },
+  args: {
+    paths: {
+      type: "positional",
+      description: "One or more paths (files or directories). Defaults to config.adrDir",
+      required: false
+    },
+    cache: {
+      type: "boolean",
+      description: "Use per-file content-hash cache (use --no-cache to disable)",
+      default: true
+    },
+    "cache-dir": {
+      type: "string",
+      description: "Cache directory (default: .madr-lint/cache)",
+      required: false
+    },
+    format: {
+      type: "string",
+      description: "Reporter format: text (default), json, or sarif",
+      default: "text"
+    }
+  },
+  run({ args }) {
+    const cwd = process.cwd();
+    let config = loadConfig(cwd);
+    if (Object.keys(config.rules).length === 0) {
+      config = resolveExtends({ extends: ["madr-lint:recommended"] });
+    }
+    const positionals = args._ ?? [];
+    const inputs = positionals.length > 0 ? positionals : [config.adrDir];
+    const seen = /* @__PURE__ */ new Set();
+    const allFiles = [];
+    for (const input of inputs) {
+      for (const file of findAdrFiles(input)) {
+        if (!seen.has(file)) {
+          seen.add(file);
+          allFiles.push(file);
+        }
+      }
+    }
+    const files = allFiles.filter(
+      (absPath) => !shouldIgnore(toPosix2(relative2(cwd, absPath)), config.ignorePatterns)
+    );
+    if (files.length === 0) {
+      const skipped = allFiles.length - files.length;
+      const note = skipped > 0 ? ` (${skipped} ignored by config)` : "";
+      const where = inputs.length === 1 ? inputs[0] : inputs.join(", ");
+      console.log(`No .md files to lint in ${where}${note}`);
+      process.exit(0);
+    }
+    const cacheEnabled = (args.cache ?? config.cache) === true;
+    const cacheDir = args["cache-dir"] ?? config.cacheLocation;
+    const cacheConfig = cacheEnabled ? {
+      dir: resolve3(cwd, cacheDir),
+      configHash: computeConfigHash({
+        rules: config.rules,
+        ignorePatterns: config.ignorePatterns,
+        madrVersion: config.madrVersion
+      }),
+      pkgVersion: pkg.version
+    } : null;
+    const allRulesArray = Object.values(rules_exports);
+    let result;
+    try {
+      result = lintFiles({
+        rules: allRulesArray,
+        ruleSeverity: config.rules,
+        files,
+        cwd,
+        cache: cacheConfig
+      });
+    } catch (err) {
+      if (err instanceof RuleOptionsError) {
+        console.error(`Invalid rule options in config: ${err.message}`);
+        process.exit(2);
+      }
+      throw err;
+    }
+    const rulesByName = new Map(
+      allRulesArray.map((r) => [r.meta.name, r])
+    );
+    const format = args.format ?? "text";
+    const reporter = reporters[format];
+    if (!reporter) {
+      console.error(
+        `Unknown --format "${format}". Available: ${Object.keys(reporters).join(", ")}`
+      );
+      process.exit(2);
+    }
+    console.log(reporter.format(result.diagnostics, rulesByName));
+    const errorCount = result.diagnostics.filter(
+      (d) => d.severity === "error"
+    ).length;
+    process.exit(errorCount > 0 ? 1 : 0);
+  }
+});
+await runMain(main);
+//# sourceMappingURL=cli.js.map