release: 4.21.0

feat(edge-audit): add report-scoped Ignore paths setting

Author: michaelpporter

CHANGELOG.md

@@ -9,6 +9,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## 4.X
 
+### [4.21.0](https://github.com/michaelpporter/breadcrumbs/compare/4.20.0...4.21.0) (2026-06-30)
+
+### Features
+
+* The edge audit report now has an **Ignore paths** setting (**Settings → Commands → Edge audit**). Notes inside a listed folder/path are left out of the whole report — orphans, dangling edges, and the field checks alike. Matching uses folder semantics (one path per line; a note matches if its path equals, or is inside, a listed path), so `Templates` covers everything under that folder. This is report-only: unlike the global **Excluded folders** setting, ignored notes still get their breadcrumb edges in the graph — they just don't clutter the audit.
+
 ### [4.20.0](https://github.com/michaelpporter/breadcrumbs/compare/4.19.4...4.20.0) (2026-06-29)
 
 ### Features

manifest.json

@@ -1,7 +1,7 @@
 {
 	"id": "breadcrumbs",
 	"name": "Breadcrumbs",
-	"version": "4.20.0",
+	"version": "4.21.0",
 	"minAppVersion": "1.13.0",
 	"description": "Add structured hierarchies to your notes.",
 	"author": "MichaelPPorter",

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "breadcrumbs",
-	"version": "4.20.0",
+	"version": "4.21.0",
 	"description": "Add typed-links to your Obsidian notes",
 	"main": "main.js",
 	"scripts": {

src/commands/edge_audit/analyze.ts

@@ -51,6 +51,39 @@ export interface EdgeAuditReport {
 /** Stable key for a directed (source → target) edge pair. */
 const pair_key = (e: EdgeFact) => `${e.source}\n${e.target}`;
 
+/**
+ * True if `path` is inside (or equal to) any ignore entry. Entries are
+ * folder/path prefixes, matched the same way as the graph's excluded folders.
+ * (Kept local so this module stays free of the Obsidian/WASM-coupled helper.)
+ */
+const is_ignored = (path: string, ignore_paths: string[]) =>
+	ignore_paths.some((raw) => {
+		const entry = raw.replace(/\/+$/, "");
+		if (!entry) return false;
+		return path === entry || path.startsWith(entry + "/");
+	});
+
+/**
+ * Drop ignored notes and every edge touching one, so all checks below run as if
+ * those paths don't exist in the graph. Report-scoped: the graph itself is
+ * untouched. Entries are folder/path prefixes.
+ */
+export const prune_ignored = (
+	facts: GraphFacts,
+	ignore_paths: string[],
+): GraphFacts => {
+	if (ignore_paths.length === 0) return facts;
+
+	return {
+		nodes: facts.nodes.filter((n) => !is_ignored(n.path, ignore_paths)),
+		edges: facts.edges.filter(
+			(e) =>
+				!is_ignored(e.source, ignore_paths) &&
+				!is_ignored(e.target, ignore_paths),
+		),
+	};
+};
+
 /** Edge fields defined in settings that produce no edges at all (explicit or implied). */
 export const find_unused_fields = (
 	facts: GraphFacts,
@@ -114,26 +147,16 @@ export const find_mergeable_fields = (facts: GraphFacts): MergeableGroup[] => {
 		.sort((a, b) => a.fields[0].localeCompare(b.fields[0]));
 };
 
-/**
- * Resolved notes with no edges in or out — outside the breadcrumb structure.
- * `exclude_paths` keeps the report file itself off the list.
- */
-export const find_orphan_notes = (
-	facts: GraphFacts,
-	exclude_paths: string[] = [],
-): string[] => {
+/** Resolved notes with no edges in or out — outside the breadcrumb structure. */
+export const find_orphan_notes = (facts: GraphFacts): string[] => {
 	const connected = new Set<string>();
 	for (const e of facts.edges) {
 		connected.add(e.source);
 		connected.add(e.target);
 	}
 
-	const excluded = new Set(exclude_paths);
-
 	return facts.nodes
-		.filter(
-			(n) => n.resolved && !connected.has(n.path) && !excluded.has(n.path),
-		)
+		.filter((n) => n.resolved && !connected.has(n.path))
 		.map((n) => n.path)
 		.sort();
 };
@@ -152,11 +175,15 @@ export const find_dangling_edges = (facts: GraphFacts): DanglingEdge[] =>
 
 export const build_edge_audit = (
 	facts: GraphFacts,
-	opts: { field_labels: string[]; exclude_paths?: string[] },
-): EdgeAuditReport => ({
-	unused_fields: find_unused_fields(facts, opts.field_labels),
-	implied_only_fields: find_implied_only_fields(facts),
-	mergeable_groups: find_mergeable_fields(facts),
-	orphan_notes: find_orphan_notes(facts, opts.exclude_paths),
-	dangling_edges: find_dangling_edges(facts),
-});
+	opts: { field_labels: string[]; ignore_paths?: string[] },
+): EdgeAuditReport => {
+	const pruned = prune_ignored(facts, opts.ignore_paths ?? []);
+
+	return {
+		unused_fields: find_unused_fields(pruned, opts.field_labels),
+		implied_only_fields: find_implied_only_fields(pruned),
+		mergeable_groups: find_mergeable_fields(pruned),
+		orphan_notes: find_orphan_notes(pruned),
+		dangling_edges: find_dangling_edges(pruned),
+	};
+};

src/commands/edge_audit/index.ts

@@ -143,8 +143,11 @@ export const generate_edge_audit_report = async (plugin: BreadcrumbsPlugin) => {
 
 	const report = build_edge_audit(facts, {
 		field_labels: plugin.settings.edge_fields.map((f) => f.label),
-		// Keep the report note itself off the orphan list.
-		exclude_paths: [report_path],
+		// User-configured ignores, plus the report note itself.
+		ignore_paths: [
+			...plugin.settings.commands.edge_audit.ignore_paths,
+			report_path,
+		],
 	});
 
 	const content = render_edge_audit_report(report, new Date());

src/const/settings.ts

@@ -269,6 +269,7 @@ export const DEFAULT_SETTINGS: BreadcrumbsSettings = {
 
 		edge_audit: {
 			report_path: "Breadcrumbs Edge Audit.md",
+			ignore_paths: [],
 		},
 	},
 

src/interfaces/settings.ts

@@ -247,6 +247,8 @@ export interface BreadcrumbsSettings {
 
 		edge_audit: {
 			report_path: string;
+			/** Folder/path prefixes whose notes are left out of the audit report. */
+			ignore_paths: string[];
 		};
 	};
 

src/settings/EdgeAuditSettings.ts

@@ -1,3 +1,4 @@
+import { Setting } from "obsidian";
 import type BreadcrumbsPlugin from "src/main";
 import { new_setting } from "src/utils/settings";
 
@@ -21,4 +22,27 @@ export const _add_settings_edge_audit = (
 			},
 		},
 	});
+
+	new Setting(contentEl)
+		.setName("Ignore paths")
+		.setDesc(
+			"Notes inside these paths are left out of the audit report (orphans, dangling edges, and field checks). One folder path per line. A note is ignored if its path equals, or is inside, a listed path. This is report-only — graph edges are unaffected.",
+		)
+		.addTextArea((text) => {
+			text.setPlaceholder("Templates\narchive/old").setValue(
+				settings.commands.edge_audit.ignore_paths.join("\n"),
+			);
+
+			text.inputEl.rows = 4;
+
+			text.inputEl.onblur = async () => {
+				settings.commands.edge_audit.ignore_paths = text
+					.getValue()
+					.split("\n")
+					.map((line) => line.trim())
+					.filter((line) => line.length > 0);
+
+				await plugin.commitSettings("none");
+			};
+		});
 };

tests/commands/edge_audit.test.ts

@@ -5,6 +5,7 @@ import {
 	find_mergeable_fields,
 	find_orphan_notes,
 	find_unused_fields,
+	prune_ignored,
 	type EdgeFact,
 	type GraphFacts,
 	type NodeFact,
@@ -138,19 +139,18 @@ describe("find_mergeable_fields", () => {
 });
 
 describe("find_orphan_notes", () => {
-	test("resolved notes with no edges, excluding the report file", () => {
+	test("resolved notes with no edges; unresolved notes are not orphans", () => {
 		const f = facts(
 			[
 				node("a.md"),
 				node("b.md"),
 				node("lonely.md"),
-				node("report.md"),
 				node("ghost.md", false),
 			],
 			[edge("up", "a.md", "b.md")],
 		);
 
-		expect(find_orphan_notes(f, ["report.md"])).toStrictEqual(["lonely.md"]);
+		expect(find_orphan_notes(f)).toStrictEqual(["lonely.md"]);
 	});
 
 	test("a note that is only an edge target is not an orphan", () => {
@@ -179,6 +179,50 @@ describe("find_dangling_edges", () => {
 	});
 });
 
+describe("prune_ignored", () => {
+	test("drops ignored notes and every edge touching one", () => {
+		const f = facts(
+			[node("a.md"), node("Templates/t.md"), node("b.md")],
+			[
+				edge("up", "a.md", "b.md"),
+				edge("up", "a.md", "Templates/t.md"),
+				edge("up", "Templates/t.md", "b.md"),
+			],
+		);
+
+		expect(prune_ignored(f, ["Templates"])).toStrictEqual(
+			facts([node("a.md"), node("b.md")], [edge("up", "a.md", "b.md")]),
+		);
+	});
+
+	test("matches folder prefixes, not bare string prefixes", () => {
+		const f = facts(
+			[node("Templates/t.md"), node("TemplatesArchive/x.md")],
+			[],
+		);
+
+		// "TemplatesArchive" must not be caught by the "Templates" entry.
+		expect(prune_ignored(f, ["Templates"])).toStrictEqual(
+			facts([node("TemplatesArchive/x.md")], []),
+		);
+	});
+
+	test("an exact path entry ignores just that note", () => {
+		const f = facts([node("a.md"), node("report.md")], []);
+
+		expect(prune_ignored(f, ["report.md"])).toStrictEqual(
+			facts([node("a.md")], []),
+		);
+	});
+
+	test("blank and empty entries are no-ops", () => {
+		const f = facts([node("a.md")], []);
+
+		expect(prune_ignored(f, [])).toStrictEqual(f);
+		expect(prune_ignored(f, ["", "   "])).toStrictEqual(f);
+	});
+});
+
 describe("build_edge_audit", () => {
 	test("assembles every section", () => {
 		const f = facts(
@@ -192,7 +236,6 @@ describe("build_edge_audit", () => {
 
 		const report = build_edge_audit(f, {
 			field_labels: ["up", "parent", "unused"],
-			exclude_paths: [],
 		});
 
 		expect(report).toStrictEqual({
@@ -205,4 +248,25 @@ describe("build_edge_audit", () => {
 			],
 		});
 	});
+
+	test("ignore_paths removes notes from every check", () => {
+		const f = facts(
+			[node("a.md"), node("b.md"), node("Templates/lonely.md")],
+			[
+				edge("up", "a.md", "b.md"),
+				// a dangling edge from an ignored note must not be reported
+				edge("up", "Templates/lonely.md", "missing.md", {
+					target_resolved: false,
+				}),
+			],
+		);
+
+		const report = build_edge_audit(f, {
+			field_labels: ["up"],
+			ignore_paths: ["Templates"],
+		});
+
+		expect(report.orphan_notes).toStrictEqual([]);
+		expect(report.dangling_edges).toStrictEqual([]);
+	});
 });

versions.json

@@ -63,5 +63,6 @@
 	"4.19.2": "1.13.0",
 	"4.19.3": "1.13.0",
 	"4.19.4": "1.13.0",
-	"4.20.0": "1.13.0"
+	"4.20.0": "1.13.0",
+	"4.21.0": "1.13.0"
 }