@riebeckite/plugin-diagnostics 0.0.1

package/dist/bin.js

@@ -0,0 +1,1168 @@
+// bin.ts
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { resolveConfigModule } from "@riebeckite/core";
+
+// index.ts
+import { definePlugin, FileSystemContentSource as FileSystemContentSource2 } from "@riebeckite/core";
+
+// src/checks/shared.ts
+var PLUGIN_NAME = "diagnostics";
+var DEFAULT_SEVERITY = {
+  "broken-wikilink": "error",
+  "broken-image": "error",
+  "broken-link": "error",
+  "unused-asset": "warning",
+  "orphan-note": "info",
+  "missing-frontmatter": "warning",
+  "publish-conflict": "warning",
+  "duplicate-title": "warning",
+  "slug-collision": "error",
+  "excluded-public": "warning",
+  "publish-boundary": "warning",
+  "internal-error": "error"
+};
+function createAnalysisState() {
+  return {
+    referencedAssets: /* @__PURE__ */ new Set(),
+    incoming: /* @__PURE__ */ new Map()
+  };
+}
+function normalizeOptions(options) {
+  return {
+    reportUnusedAssets: options.reportUnusedAssets ?? false,
+    reportOrphans: options.reportOrphans ?? false,
+    requiredFrontmatter: options.requiredFrontmatter ?? [],
+    severity: options.severity ?? {}
+  };
+}
+function addIncoming(state, target, source) {
+  const sources = state.incoming.get(target) ?? /* @__PURE__ */ new Set();
+  sources.add(source);
+  state.incoming.set(target, sources);
+}
+function pushDiagnostic(diagnostics, options, location, code, message, target, suggestion, line, column) {
+  diagnostics.push({
+    pluginName: PLUGIN_NAME,
+    code,
+    severity: options.severity[code] ?? DEFAULT_SEVERITY[code] ?? "warning",
+    message,
+    slug: location.slug,
+    filePath: location.filePath,
+    line,
+    column,
+    target,
+    suggestion
+  });
+}
+
+// src/checks/assets.ts
+function checkUnusedAssets(source, state, options, diagnostics) {
+  if (!options.reportUnusedAssets) return;
+  for (const asset of source.assets) {
+    if (!state.referencedAssets.has(asset.relativePath))
+      pushDiagnostic(
+        diagnostics,
+        options,
+        { filePath: asset.relativePath },
+        "unused-asset",
+        `image "${asset.relativePath}" is never referenced by any note`,
+        asset.relativePath,
+        "reference the image from a note or remove it"
+      );
+  }
+}
+
+// src/checks/excluded_public.ts
+function checkExcludedPublic(source, options, diagnostics) {
+  for (const note of source.excludedNotes) {
+    if (note.fm.values.publish === true)
+      pushDiagnostic(
+        diagnostics,
+        options,
+        { slug: note.slug, filePath: note.relativePath },
+        "excluded-public",
+        `excluded note "${note.slug}" is marked publish: true`,
+        note.slug,
+        "unset publish or move the note outside of the excluded directory"
+      );
+  }
+}
+
+// src/frontmatter.ts
+function parseFrontmatter(markdown) {
+  const match = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match?.[1]) return { hasFrontmatter: false, values: {} };
+  return { hasFrontmatter: true, values: parseFrontmatterBlock(match[1]) };
+}
+function hasField(values, field) {
+  if (!(field in values)) return false;
+  const value = values[field];
+  if (value === null || value === void 0) return false;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "string") return value.trim() !== "";
+  return true;
+}
+function getNoteTitle(values, slug) {
+  const title = values.title;
+  return typeof title === "string" && title.trim() ? title : slug;
+}
+function parseFrontmatterBlock(body) {
+  const values = {};
+  const lines = body.split(/\r?\n/);
+  let openKey = null;
+  const pending = [];
+  const closeList = () => {
+    if (openKey !== null) {
+      values[openKey] = pending.length > 0 ? [...pending] : [];
+    }
+    openKey = null;
+    pending.length = 0;
+  };
+  for (const line of lines) {
+    const keyMatch = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (keyMatch) {
+      closeList();
+      const [, key, rest] = keyMatch;
+      const trimmed = rest.trim();
+      if (trimmed === "") {
+        openKey = key;
+      } else if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        values[key] = trimmed.slice(1, -1).split(",").map((item) => stripQuotes(item.trim())).filter(Boolean);
+      } else {
+        values[key] = parseScalar(trimmed);
+      }
+      continue;
+    }
+    const itemMatch = line.match(/^\s*-\s+(.+)$/);
+    if (itemMatch) {
+      if (openKey !== null) {
+        pending.push(stripQuotes(itemMatch[1].trim()));
+      }
+      continue;
+    }
+    if (line.trim() === "") continue;
+    closeList();
+  }
+  closeList();
+  return values;
+}
+function parseScalar(value) {
+  if (/^true$/i.test(value)) return true;
+  if (/^false$/i.test(value)) return false;
+  return stripQuotes(value);
+}
+function stripQuotes(value) {
+  return value.trim().replace(/^['"]|['"]$/g, "");
+}
+
+// src/vault.ts
+import {
+  FileSystemContentSource,
+  IMAGE_EXTENSIONS,
+  isAttachmentPath,
+  isExcluded,
+  isPublishable
+} from "@riebeckite/core";
+var NOTE_EXTENSION = "md";
+var WIKILINK_TARGET_PATTERN = /(!)?\[\[([^\]|#^]+)(?:#(\^?[^\]|]+))?(?:\|[^\]]+)?\]\]/g;
+async function scanVault(config) {
+  const source = config.source ?? new FileSystemContentSource(config.directory, config.exclude);
+  const targetIndex = /* @__PURE__ */ new Map();
+  const filePaths = /* @__PURE__ */ new Set();
+  const noteSlugs = /* @__PURE__ */ new Set();
+  const noteBySlug = /* @__PURE__ */ new Map();
+  const assetPaths = /* @__PURE__ */ new Set();
+  const assets = [];
+  const includedNotes = [];
+  const excludedNotes = [];
+  const entries = await source.scan();
+  for (const entry of entries) {
+    const relative = entry.path;
+    filePaths.add(relative);
+    const excluded = isExcluded(config.exclude, relative);
+    const extension = getExtension(relative);
+    if (extension === NOTE_EXTENSION) {
+      const slug = relative.slice(0, -NOTE_EXTENSION.length - 1);
+      const markdown = normalizeMarkdown(await readMarkdown(source, entry));
+      const fm = parseFrontmatter(markdown);
+      const note = {
+        relativePath: relative,
+        slug,
+        markdown,
+        fm,
+        headings: extractHeadings(markdown),
+        blockIds: extractBlockIds(markdown),
+        excluded,
+        published: isPublishable(config.publishStrategy, fm.values)
+      };
+      if (excluded) {
+        excludedNotes.push(note);
+        continue;
+      }
+      includedNotes.push(note);
+      noteSlugs.add(slug);
+      noteBySlug.set(slug, note);
+      addToIndex(targetIndex, slug, "note", fm);
+      continue;
+    }
+    if (excluded) continue;
+    addToIndex(
+      targetIndex,
+      relative,
+      IMAGE_EXTENSIONS.includes(extension) ? "image" : "attachment"
+    );
+    if (IMAGE_EXTENSIONS.includes(extension)) {
+      assetPaths.add(relative);
+      assets.push({ relativePath: relative, extension });
+    }
+  }
+  return {
+    includedNotes,
+    excludedNotes,
+    noteSlugs,
+    noteBySlug,
+    assetPaths,
+    assets,
+    filePaths,
+    targetIndex
+  };
+}
+function getWikilinkMatches(markdown) {
+  WIKILINK_TARGET_PATTERN.lastIndex = 0;
+  const matches = [];
+  for (let match = WIKILINK_TARGET_PATTERN.exec(markdown); match !== null; match = WIKILINK_TARGET_PATTERN.exec(markdown)) {
+    const target = match[2]?.trim();
+    if (!target) continue;
+    const fragment = match[3]?.trim() || null;
+    matches.push({
+      embed: match[1] === "!",
+      target,
+      fragment,
+      index: match.index
+    });
+  }
+  return matches;
+}
+function resolveWikilinkTarget(target, targetIndex) {
+  let key = target.trim().toLowerCase();
+  if (key.endsWith(`.${NOTE_EXTENSION}`)) {
+    key = key.slice(0, -NOTE_EXTENSION.length - 1);
+  }
+  return targetIndex.get(key) ?? null;
+}
+function isImageTarget(target) {
+  const extension = getExtension(target);
+  return IMAGE_EXTENSIONS.includes(extension);
+}
+function isAssetTarget(target) {
+  return isImageTarget(target) || isAttachmentPath(target);
+}
+function resolveLocalReference(noteSlug, url) {
+  if (!url) return null;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(url)) return null;
+  if (url.startsWith("#")) return null;
+  if (url.startsWith("/")) return null;
+  const withoutAnchor = url.split(/[?#]/)[0];
+  if (!withoutAnchor) return null;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(withoutAnchor);
+  } catch {
+    return null;
+  }
+  const base = noteSlug.split("/").slice(0, -1);
+  const resolved = normalizeRelativePath([...base, ...decoded.split("/")]);
+  if (resolved === ".." || resolved.startsWith("../")) return null;
+  return resolved;
+}
+function resolveVaultRelative(value) {
+  if (!value) return null;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(value)) return null;
+  if (value.startsWith("/")) return null;
+  const withoutAnchor = value.split(/[?#]/)[0];
+  if (!withoutAnchor) return null;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(withoutAnchor);
+  } catch {
+    return null;
+  }
+  return normalizeRelativePath(decoded.split("/"));
+}
+function addToIndex(targetIndex, value, kind, fm) {
+  const setKey = (key) => {
+    const existing = targetIndex.get(key);
+    if (existing && !(existing.kind !== "note" && kind === "note")) return;
+    targetIndex.set(key, { kind, value });
+  };
+  const parts = value.split("/");
+  for (let i = parts.length - 1; i >= 0; i--) {
+    setKey(parts.slice(i).join("/").toLowerCase());
+  }
+  if (fm) {
+    const aliases = fm.values.aliases;
+    const aliasList = Array.isArray(aliases) ? aliases.filter((alias) => typeof alias === "string") : [];
+    for (const alias of aliasList) {
+      const key = alias.trim().toLowerCase();
+      if (key) setKey(key);
+    }
+    return;
+  }
+  const stemValue = value.replace(/\.[^/.]+$/, "");
+  if (stemValue !== value) {
+    const stemParts = stemValue.split("/");
+    for (let i = stemParts.length - 1; i >= 0; i--) {
+      setKey(stemParts.slice(i).join("/").toLowerCase());
+    }
+  }
+}
+function extractHeadings(markdown) {
+  const headings = /* @__PURE__ */ new Set();
+  for (const line of markdown.split("\n")) {
+    const match = line.match(/^#{1,6}\s+(.+?)\s*#*\s*$/);
+    const heading = match?.[1]?.trim();
+    if (heading) headings.add(heading.toLowerCase());
+  }
+  return headings;
+}
+function extractBlockIds(markdown) {
+  const blockIds = /* @__PURE__ */ new Set();
+  for (const line of markdown.split("\n")) {
+    const match = line.match(/(?:^|\s)\^([A-Za-z0-9_-]+)\s*$/);
+    const blockId = match?.[1];
+    if (blockId) blockIds.add(blockId);
+  }
+  return blockIds;
+}
+function fragmentExists(note, fragment) {
+  const raw = fragment.trim();
+  if (raw.startsWith("^")) {
+    const blockId = raw.slice(1).trim();
+    return blockId !== "" && note.blockIds.has(blockId);
+  }
+  const heading = raw.toLowerCase();
+  return heading !== "" && note.headings.has(heading);
+}
+function normalizeMarkdown(markdown) {
+  return markdown.replace(/\r\n/g, "\n");
+}
+function getExtension(filePath) {
+  const lastSegment = filePath.split("/").pop() ?? filePath;
+  const dotIndex = lastSegment.lastIndexOf(".");
+  if (dotIndex < 0) return "";
+  return lastSegment.slice(dotIndex + 1).toLowerCase();
+}
+async function readMarkdown(source, entry) {
+  const content = await source.read(entry);
+  return typeof content === "string" ? content : new TextDecoder().decode(content);
+}
+function normalizeRelativePath(parts) {
+  const normalized = [];
+  for (const part of parts) {
+    if (!part || part === ".") continue;
+    if (part === "..") {
+      if (normalized.length === 0) return "..";
+      normalized.pop();
+      continue;
+    }
+    normalized.push(part);
+  }
+  return normalized.join("/");
+}
+
+// src/checks/frontmatter.ts
+function checkFrontmatter(note, source, state, options, diagnostics) {
+  const location = { slug: note.slug, filePath: note.relativePath };
+  const values = note.fm.values;
+  if (!note.fm.hasFrontmatter) {
+    pushDiagnostic(
+      diagnostics,
+      options,
+      location,
+      "missing-frontmatter",
+      "note has no frontmatter",
+      note.slug,
+      "add frontmatter with the required fields"
+    );
+  } else {
+    for (const field of options.requiredFrontmatter) {
+      if (!hasField(values, field))
+        pushDiagnostic(
+          diagnostics,
+          options,
+          location,
+          "missing-frontmatter",
+          `missing required frontmatter field "${field}"`,
+          field,
+          `add "${field}" to the frontmatter`
+        );
+    }
+  }
+  if (values.publish === true && values.draft === true)
+    pushDiagnostic(
+      diagnostics,
+      options,
+      location,
+      "publish-conflict",
+      "frontmatter sets both publish: true and draft: true",
+      note.slug,
+      "set only one of publish or draft"
+    );
+  if (values.publish === true && values.private === true)
+    pushDiagnostic(
+      diagnostics,
+      options,
+      location,
+      "publish-conflict",
+      "frontmatter sets both publish: true and private: true",
+      note.slug,
+      "set only one of publish or private"
+    );
+  for (const field of ["image", "ogImage"]) {
+    const raw = values[field];
+    if (typeof raw !== "string" || !raw.trim()) continue;
+    const resolved = resolveLocalReference(note.slug, raw) ?? resolveVaultRelative(raw);
+    if (resolved && source.assetPaths.has(resolved))
+      state.referencedAssets.add(resolved);
+  }
+}
+
+// src/markdown_links.ts
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import { visit } from "unist-util-visit";
+function extractMarkdownReferences(markdown) {
+  const tree = unified().use(remarkParse).parse(markdown);
+  const references = [];
+  visit(tree, (node) => {
+    if (node.type !== "link" && node.type !== "image") return;
+    const url = node.url;
+    if (!url) return;
+    const start = node.position?.start;
+    references.push({
+      kind: node.type,
+      url,
+      line: start?.line ?? 0,
+      column: start?.column ?? 0
+    });
+  });
+  return references;
+}
+
+// src/checks/markdown_references.ts
+function checkMarkdownReferences(note, source, state, options, diagnostics) {
+  const location = { slug: note.slug, filePath: note.relativePath };
+  for (const reference of extractMarkdownReferences(note.markdown)) {
+    const resolved = resolveLocalReference(note.slug, reference.url);
+    if (!resolved) continue;
+    const extension = getExtension(resolved);
+    if (reference.kind === "image") {
+      if (source.assetPaths.has(resolved) || source.filePaths.has(resolved))
+        state.referencedAssets.add(resolved);
+      else
+        pushDiagnostic(
+          diagnostics,
+          options,
+          location,
+          "broken-image",
+          `image "${reference.url}" does not exist`,
+          reference.url,
+          "fix the image path or add the image to the vault",
+          reference.line,
+          reference.column
+        );
+      continue;
+    }
+    if (extension === "md") {
+      const targetSlug = resolved.slice(0, -3);
+      if (source.noteSlugs.has(targetSlug)) {
+        if (targetSlug !== note.slug) addIncoming(state, targetSlug, note.slug);
+      } else if (source.filePaths.has(resolved)) {
+        pushDiagnostic(
+          diagnostics,
+          options,
+          location,
+          "broken-link",
+          `link "${reference.url}" points to an excluded note that will not be published`,
+          reference.url,
+          "link to a published note or remove the link",
+          reference.line,
+          reference.column
+        );
+      } else {
+        pushDiagnostic(
+          diagnostics,
+          options,
+          location,
+          "broken-link",
+          `link "${reference.url}" points to a missing note`,
+          reference.url,
+          "fix the link to an existing note",
+          reference.line,
+          reference.column
+        );
+      }
+      continue;
+    }
+    if (isImageTarget(resolved)) {
+      if (source.assetPaths.has(resolved)) state.referencedAssets.add(resolved);
+      else
+        pushDiagnostic(
+          diagnostics,
+          options,
+          location,
+          "broken-image",
+          `image link "${reference.url}" does not exist`,
+          reference.url,
+          "fix the image path or add the image to the vault",
+          reference.line,
+          reference.column
+        );
+      continue;
+    }
+    if (!source.filePaths.has(resolved))
+      pushDiagnostic(
+        diagnostics,
+        options,
+        location,
+        "broken-link",
+        `link "${reference.url}" points to a missing file`,
+        reference.url,
+        "fix the link to an existing file",
+        reference.line,
+        reference.column
+      );
+  }
+}
+
+// src/checks/note_metadata.ts
+function checkSlugCollisions(source, options, diagnostics) {
+  const byKey = groupNotes(
+    source.includedNotes,
+    (note) => note.slug.toLowerCase()
+  );
+  for (const [key, notes] of byKey) {
+    if (notes.length < 2) continue;
+    const others = notes.map((note) => note.slug).join(", ");
+    for (const note of notes)
+      pushDiagnostic(
+        diagnostics,
+        options,
+        { slug: note.slug, filePath: note.relativePath },
+        "slug-collision",
+        `slug "${note.slug}" collides with ${others} case-insensitively`,
+        key,
+        "rename one of the notes to avoid the collision"
+      );
+  }
+}
+function checkDuplicateTitles(source, options, diagnostics) {
+  const byTitle = groupNotes(
+    source.includedNotes.filter((note) => note.published),
+    (note) => getNoteTitle(note.fm.values, note.slug).toLowerCase()
+  );
+  for (const [title, notes] of byTitle) {
+    if (notes.length < 2) continue;
+    const slugs = notes.map((note) => note.slug).join(", ");
+    for (const note of notes)
+      pushDiagnostic(
+        diagnostics,
+        options,
+        { slug: note.slug, filePath: note.relativePath },
+        "duplicate-title",
+        `title "${title}" is used by multiple published notes: ${slugs}`,
+        typeof notes[0]?.fm.values.title === "string" ? notes[0].fm.values.title : title,
+        "rename the title or the note"
+      );
+  }
+}
+function groupNotes(notes, keyFor) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const note of notes) {
+    const key = keyFor(note);
+    const group = groups.get(key) ?? [];
+    group.push(note);
+    groups.set(key, group);
+  }
+  return groups;
+}
+
+// src/checks/orphans.ts
+function checkOrphans(source, state, options, diagnostics) {
+  if (!options.reportOrphans) return;
+  for (const note of source.includedNotes) {
+    if (!note.published || note.slug === "index" || (state.incoming.get(note.slug)?.size ?? 0) > 0)
+      continue;
+    pushDiagnostic(
+      diagnostics,
+      options,
+      { slug: note.slug, filePath: note.relativePath },
+      "orphan-note",
+      "published note has no incoming links",
+      note.slug,
+      "link to this note from another note"
+    );
+  }
+}
+
+// src/location.ts
+var LineMapper = class {
+  starts;
+  constructor(text) {
+    const starts = [0];
+    for (let i = 0; i < text.length; i++) {
+      if (text[i] === "\n") starts.push(i + 1);
+    }
+    this.starts = starts;
+  }
+  positionAt(index) {
+    const starts = this.starts;
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+      const mid = Math.ceil((low + high) / 2);
+      if ((starts[mid] ?? 0) <= index) {
+        low = mid;
+      } else {
+        high = mid - 1;
+      }
+    }
+    return { line: low + 1, column: index - (starts[low] ?? 0) + 1 };
+  }
+};
+
+// src/checks/publish_boundary.ts
+function checkPublishBoundary(source, options, diagnostics) {
+  for (const note of source.includedNotes) {
+    if (!note.published) continue;
+    const location = {
+      slug: note.slug,
+      filePath: note.relativePath
+    };
+    const position = new LineMapper(note.markdown);
+    for (const match of getWikilinkMatches(note.markdown)) {
+      const resolved = resolveWikilinkTarget(match.target, source.targetIndex);
+      if (!resolved || resolved.kind !== "note") continue;
+      const { line, column } = position.positionAt(match.index);
+      reportBoundaryReference(
+        source,
+        options,
+        diagnostics,
+        location,
+        resolved.value,
+        match.embed ? "embeds" : "links to",
+        line,
+        column
+      );
+    }
+    for (const reference of extractMarkdownReferences(note.markdown)) {
+      const resolved = resolveLocalReference(note.slug, reference.url);
+      if (!resolved || getExtension(resolved) !== "md") continue;
+      reportBoundaryReference(
+        source,
+        options,
+        diagnostics,
+        location,
+        resolved.slice(0, -3),
+        "links to",
+        reference.line,
+        reference.column
+      );
+    }
+  }
+}
+function reportBoundaryReference(source, options, diagnostics, location, targetSlug, verb, line, column) {
+  if (targetSlug === location.slug) return;
+  const target = source.noteBySlug.get(targetSlug);
+  if (!target || target.published) return;
+  pushDiagnostic(
+    diagnostics,
+    options,
+    location,
+    "publish-boundary",
+    `published note "${location.slug}" ${verb} non-published note "${targetSlug}"`,
+    targetSlug,
+    "publish the target note or remove the reference from published content",
+    line,
+    column
+  );
+}
+
+// src/checks/wikilinks.ts
+function checkWikilinks(note, source, state, options, diagnostics) {
+  const position = new LineMapper(note.markdown);
+  const location = { slug: note.slug, filePath: note.relativePath };
+  for (const match of getWikilinkMatches(note.markdown)) {
+    const { line, column } = position.positionAt(match.index);
+    const rawTarget = match.target;
+    const resolved = resolveWikilinkTarget(rawTarget, source.targetIndex);
+    if (!resolved) {
+      const targetIsImage = isImageTarget(rawTarget);
+      const targetIsAsset = isAssetTarget(rawTarget);
+      const code = targetIsImage || match.embed ? "broken-image" : "broken-wikilink";
+      const verb = targetIsAsset || match.embed ? "embed" : "link";
+      pushDiagnostic(
+        diagnostics,
+        options,
+        location,
+        code,
+        `wikilink ${verb} "[[${rawTarget}]]" does not resolve to any published note or asset`,
+        rawTarget,
+        targetIsAsset || match.embed ? "fix the asset path or add the asset to the vault" : "create the target note or fix the link",
+        line,
+        column
+      );
+      continue;
+    }
+    if (resolved.kind === "note") {
+      if (match.fragment) {
+        const targetNote = source.noteBySlug.get(resolved.value);
+        if (targetNote && !fragmentExists(targetNote, match.fragment)) {
+          pushDiagnostic(
+            diagnostics,
+            options,
+            location,
+            "broken-wikilink",
+            `wikilink fragment "#${match.fragment}" does not exist in "${resolved.value}"`,
+            `${resolved.value}#${match.fragment}`,
+            "fix the fragment to an existing heading or block id",
+            line,
+            column
+          );
+        }
+      }
+      if (resolved.value !== note.slug)
+        addIncoming(state, resolved.value, note.slug);
+      continue;
+    }
+    if (resolved.kind === "image" || resolved.kind === "attachment") {
+      state.referencedAssets.add(resolved.value);
+    }
+  }
+}
+
+// src/analyze.ts
+async function analyzeContent(config, options = {}) {
+  const source = await scanVault(config);
+  const normalizedOptions = normalizeOptions(options);
+  const state = createAnalysisState();
+  const diagnostics = [];
+  for (const note of source.includedNotes) {
+    checkWikilinks(note, source, state, normalizedOptions, diagnostics);
+    checkMarkdownReferences(
+      note,
+      source,
+      state,
+      normalizedOptions,
+      diagnostics
+    );
+    checkFrontmatter(note, source, state, normalizedOptions, diagnostics);
+  }
+  checkSlugCollisions(source, normalizedOptions, diagnostics);
+  checkDuplicateTitles(source, normalizedOptions, diagnostics);
+  checkOrphans(source, state, normalizedOptions, diagnostics);
+  checkUnusedAssets(source, state, normalizedOptions, diagnostics);
+  checkExcludedPublic(source, normalizedOptions, diagnostics);
+  checkPublishBoundary(source, normalizedOptions, diagnostics);
+  return diagnostics;
+}
+
+// src/report.ts
+var SEVERITY_ORDER = {
+  error: 0,
+  warning: 1,
+  info: 2
+};
+function buildReport(diagnostics) {
+  const errors = [];
+  const warnings = [];
+  const infos = [];
+  for (const diagnostic of diagnostics) {
+    switch (diagnostic.severity) {
+      case "error":
+        errors.push(diagnostic);
+        break;
+      case "warning":
+        warnings.push(diagnostic);
+        break;
+      default:
+        infos.push(diagnostic);
+        break;
+    }
+  }
+  return {
+    diagnostics,
+    errors,
+    warnings,
+    infos,
+    hasErrors: errors.length > 0,
+    hasWarnings: warnings.length > 0,
+    summary: summarize(diagnostics),
+    byCode: groupByCode(diagnostics)
+  };
+}
+function summarize(diagnostics) {
+  let error = 0;
+  let warning = 0;
+  let info = 0;
+  for (const diagnostic of diagnostics) {
+    switch (diagnostic.severity) {
+      case "error":
+        error++;
+        break;
+      case "warning":
+        warning++;
+        break;
+      default:
+        info++;
+        break;
+    }
+  }
+  return { total: diagnostics.length, error, warning, info };
+}
+function groupByCode(diagnostics) {
+  const byCode = /* @__PURE__ */ new Map();
+  for (const diagnostic of diagnostics) {
+    const group = byCode.get(diagnostic.code) ?? [];
+    group.push(diagnostic);
+    byCode.set(diagnostic.code, group);
+  }
+  return byCode;
+}
+function formatDiagnostics(input, options = {}) {
+  const report = Array.isArray(input) ? buildReport(input) : input;
+  if (report.diagnostics.length === 0) return "No diagnostics found.";
+  const useColor = options.color ?? hasColorSupport();
+  const color = useColor ? ansiColors : noColors;
+  const lines = [];
+  const summary = report.summary;
+  lines.push(
+    `${color.bold}${color.error}${summary.error} errors${color.reset}, ${color.yellow}${summary.warning} warnings${color.reset}, ${color.cyan}${summary.info} infos${color.reset} ${color.dim}(${summary.total} total)${color.reset}`
+  );
+  lines.push("");
+  const ordered = [...report.diagnostics].sort(compareDiagnostics);
+  for (const diagnostic of ordered) {
+    const icon = {
+      error: `${color.error}✖`,
+      warning: `${color.yellow}⚠`,
+      info: `${color.cyan}ℹ`
+    }[diagnostic.severity];
+    const location = [
+      diagnostic.filePath ?? "",
+      diagnostic.line != null ? `:${diagnostic.line}${diagnostic.column != null ? `:${diagnostic.column}` : ""}` : ""
+    ].join("");
+    lines.push(`${icon} ${color.reset}[${diagnostic.code}] ${location}`);
+    lines.push(`    ${diagnostic.message}`);
+    if (diagnostic.target) {
+      lines.push(`    ${color.dim}target: ${diagnostic.target}${color.reset}`);
+    }
+    if (diagnostic.suggestion) {
+      lines.push(`    ${color.cyan}→ ${diagnostic.suggestion}${color.reset}`);
+    }
+  }
+  return lines.join("\n");
+}
+function compareDiagnostics(a, b) {
+  const severityDiff = SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity];
+  if (severityDiff !== 0) return severityDiff;
+  const fileDiff = (a.filePath ?? "").localeCompare(b.filePath ?? "");
+  if (fileDiff !== 0) return fileDiff;
+  const lineDiff = (a.line ?? 0) - (b.line ?? 0);
+  if (lineDiff !== 0) return lineDiff;
+  return (a.column ?? 0) - (b.column ?? 0);
+}
+function hasColorSupport() {
+  if (typeof process === "undefined") return false;
+  return Boolean(process.stdout?.isTTY);
+}
+var ansiColors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  error: "\x1B[31m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m"
+};
+var noColors = {
+  reset: "",
+  bold: "",
+  dim: "",
+  error: "",
+  yellow: "",
+  cyan: ""
+};
+
+// index.ts
+var PLUGIN_NAME2 = "diagnostics";
+async function runDiagnostics(target, options = {}) {
+  const config = toAnalyzerConfig(target, options);
+  try {
+    return buildReport(await analyzeContent(config, options));
+  } catch (error) {
+    return buildReport([createInternalError(error)]);
+  }
+}
+function createInternalError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    pluginName: PLUGIN_NAME2,
+    code: "internal-error",
+    severity: "error",
+    message: `content analysis failed: ${message}`
+  };
+}
+function toAnalyzerConfig(target, options) {
+  if (typeof target === "string") {
+    return {
+      directory: target,
+      exclude: options.exclude ?? [],
+      publishStrategy: options.publishStrategy ?? "selective"
+    };
+  }
+  return {
+    directory: target.content.directory,
+    source: target.content.source ?? new FileSystemContentSource2(
+      target.content.directory,
+      target.content.exclude
+    ),
+    exclude: [...target.content.exclude, ...options.exclude ?? []],
+    publishStrategy: target.content.filters.publishStrategy
+  };
+}
+
+// bin.ts
+var HELP = `riebeckite-diagnostics
+
+Check an Obsidian vault / Riebeckite content directory for content problems:
+broken wikilinks, broken images, broken markdown links, unused assets,
+orphan notes, missing frontmatter, publish conflicts, duplicate titles,
+slug collisions, and excluded-but-public notes.
+
+Usage:
+  riebeckite-diagnostics [options]
+
+Options:
+  --config <path>             Path to riebeckite.config.ts (loaded under tsx)
+  --content <dir>             Content directory to analyze (default: .)
+  --exclude <glob>            Extra exclude glob (repeatable)
+  --publish-strategy <mode>   explicit | selective (default: selective)
+  --report-unused-assets      Report images never referenced by any note
+  --report-orphans            Report published notes with no incoming links
+  --required-frontmatter <f>  Comma-separated required frontmatter fields
+  --fail-on-error             Exit with code 1 when errors are found (default)
+  --exit-on <severity>        Exit with code 1 at/above severity (info|warning|error)
+  --format <text|json>        Output format (default: text)
+  --no-color                  Disable ANSI colors
+  -h, --help                  Show this help
+
+Exit codes:
+  0  no errors
+  1  one or more errors reported (or the --exit-on threshold is met)
+  2  invalid arguments
+`;
+async function main(argv) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (!args.config && !args.content) {
+    process.stderr.write("error: set --config <path> or --content <dir>\n\n");
+    process.stderr.write(HELP);
+    return 2;
+  }
+  const config = args.config ? await loadConfigFile(args.config) : null;
+  const options = {
+    ...config ? diagnosticsOptionsFromConfig(config) : {},
+    ...args.explicit.has("reportUnusedAssets") ? { reportUnusedAssets: args.reportUnusedAssets } : {},
+    ...args.explicit.has("reportOrphans") ? { reportOrphans: args.reportOrphans } : {},
+    ...args.explicit.has("requiredFrontmatter") ? { requiredFrontmatter: args.requiredFrontmatter } : {},
+    ...args.explicit.has("publishStrategy") ? { publishStrategy: args.publishStrategy ?? void 0 } : {},
+    exclude: [
+      ...config ? diagnosticsOptionsFromConfig(config).exclude ?? [] : [],
+      ...args.exclude
+    ]
+  };
+  let target;
+  if (config) {
+    target = config;
+  } else {
+    target = args.content ?? ".";
+  }
+  const report = await runDiagnostics(target, options);
+  writeReport(report, args);
+  if (args.exitOn) {
+    if (countAtOrAbove(report, args.exitOn) > 0) return 1;
+    return 0;
+  }
+  return report.hasErrors ? 1 : 0;
+}
+function diagnosticsOptionsFromConfig(config) {
+  const plugin = config.plugins.find(
+    (candidate) => candidate.name === "diagnostics"
+  );
+  const options = plugin?.options;
+  return options && typeof options === "object" ? options : {};
+}
+function writeReport(report, args) {
+  if (args.format === "json") {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          summary: report.summary,
+          hasErrors: report.hasErrors,
+          hasWarnings: report.hasWarnings,
+          diagnostics: report.diagnostics.map((diagnostic) => ({
+            code: diagnostic.code,
+            severity: diagnostic.severity,
+            message: diagnostic.message,
+            filePath: diagnostic.filePath,
+            slug: diagnostic.slug,
+            line: diagnostic.line,
+            column: diagnostic.column,
+            target: diagnostic.target,
+            suggestion: diagnostic.suggestion
+          }))
+        },
+        null,
+        2
+      )}
+`
+    );
+    return;
+  }
+  process.stdout.write(
+    `${formatDiagnostics(report, { color: !args.noColor })}
+`
+  );
+}
+function countAtOrAbove(report, severity) {
+  switch (severity) {
+    case "error":
+      return report.summary.error;
+    case "warning":
+      return report.summary.error + report.summary.warning;
+    default:
+      return report.summary.total;
+  }
+}
+async function loadConfigFile(configPath) {
+  const absoluteUrl = pathToFileURL(configPath);
+  let module;
+  try {
+    module = await import(absoluteUrl.href);
+  } catch (error) {
+    throw new Error(
+      `failed to load config "${configPath}": ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const resolved = resolveConfigModule(module);
+  const directory = fileURLToPath(
+    isAbsoluteFilePath(resolved.content.directory) ? pathToFileURL(resolved.content.directory) : new URL(resolved.content.directory, new URL("./", absoluteUrl))
+  );
+  return {
+    ...resolved,
+    content: {
+      ...resolved.content,
+      directory
+    }
+  };
+}
+function parseArgs(argv) {
+  const args = {
+    help: false,
+    noColor: false,
+    failOnError: false,
+    format: "text",
+    exitOn: null,
+    config: null,
+    content: null,
+    exclude: [],
+    requiredFrontmatter: [],
+    reportUnusedAssets: false,
+    reportOrphans: false,
+    publishStrategy: null,
+    explicit: /* @__PURE__ */ new Set()
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case "-h":
+      case "--help":
+        args.help = true;
+        break;
+      case "--no-color":
+        args.noColor = true;
+        break;
+      case "--fail-on-error":
+        args.failOnError = true;
+        break;
+      case "--report-unused-assets":
+        args.reportUnusedAssets = true;
+        args.explicit.add("reportUnusedAssets");
+        break;
+      case "--report-orphans":
+        args.reportOrphans = true;
+        args.explicit.add("reportOrphans");
+        break;
+      case "--format":
+        args.format = (argv[++i] ?? "text") === "json" ? "json" : "text";
+        break;
+      case "--exit-on": {
+        const value = argv[++i];
+        args.exitOn = value === "error" || value === "warning" || value === "info" ? value : null;
+        break;
+      }
+      case "--config":
+        args.config = argv[++i] ?? "";
+        break;
+      case "--content":
+        args.content = argv[++i] ?? "";
+        break;
+      case "--publish-strategy": {
+        const value = argv[++i];
+        args.publishStrategy = value === "explicit" || value === "selective" ? value : null;
+        if (args.publishStrategy) args.explicit.add("publishStrategy");
+        break;
+      }
+      case "--exclude":
+        if (argv[i + 1] && !argv[i + 1].startsWith("--")) {
+          args.exclude.push(argv[++i]);
+        }
+        break;
+      case "--required-frontmatter": {
+        args.explicit.add("requiredFrontmatter");
+        if (argv[i + 1] && !argv[i + 1].startsWith("--")) {
+          args.requiredFrontmatter.push(
+            ...(argv[++i] ?? "").split(",").map((value) => value.trim()).filter(Boolean)
+          );
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return args;
+}
+var isMain = process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url;
+function isAbsoluteFilePath(value) {
+  return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value);
+}
+if (isMain) {
+  main(process.argv.slice(2)).then(
+    (code) => {
+      process.exitCode = code;
+    },
+    (error) => {
+      process.stderr.write(
+        `error: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+      process.exitCode = 1;
+    }
+  );
+}
+export {
+  main
+};