@refract-org/analyzers 0.2.1

package/src/__tests__/section-differ.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from "vitest";
+import { buildSectionLineage, sectionDiffer } from "../section-differ.js";
+
+describe("buildSectionLineage", () => {
+  it("tracks section creation and modification across revisions", () => {
+    const revisions = [
+      { revId: 1, timestamp: "2024-01-01T00:00:00Z", content: "Lead content" },
+      { revId: 2, timestamp: "2024-01-02T00:00:00Z", content: "Lead content\n\n== History ==\nOld history" },
+      { revId: 3, timestamp: "2024-01-03T00:00:00Z", content: "Lead content\n\n== History ==\nNew history text" },
+    ];
+
+    const lineage = buildSectionLineage(revisions);
+    expect(lineage.length).toBeGreaterThan(0);
+
+    const history = lineage.find((l) => l.sectionName === "History");
+    expect(history).toBeDefined();
+    expect(history?.firstSeenRevisionId).toBe(2);
+    expect(history?.events.length).toBeGreaterThanOrEqual(2);
+    expect(history?.isActive).toBe(true);
+  });
+
+  it("detects section removal", () => {
+    const revisions = [
+      { revId: 1, timestamp: "2024-01-01T00:00:00Z", content: "Lead\n\n== A ==\nContent A\n\n== B ==\nContent B" },
+      { revId: 2, timestamp: "2024-01-02T00:00:00Z", content: "Lead\n\n== A ==\nContent A" },
+    ];
+
+    const lineage = buildSectionLineage(revisions);
+    const removedB = lineage.find((l) => l.sectionName === "B");
+    expect(removedB).toBeDefined();
+    expect(removedB?.isActive).toBe(false);
+    expect(removedB?.events.some((e) => e.eventType === "removed")).toBe(true);
+  });
+
+  it("returns empty array for no revisions", () => {
+    expect(buildSectionLineage([])).toEqual([]);
+  });
+
+  it("detects renamed sections", () => {
+    const revisions = [
+      { revId: 1, timestamp: "2024-01-01T00:00:00Z", content: "Lead\n\n== History ==\nSame content" },
+      { revId: 2, timestamp: "2024-01-02T00:00:00Z", content: "Lead\n\n== Background ==\nSame content" },
+    ];
+
+    const lineage = buildSectionLineage(revisions);
+    const renamed = lineage.find((l) => l.sectionName === "Background");
+    expect(renamed).toBeDefined();
+    expect(renamed?.events.some((e) => e.eventType === "renamed")).toBe(true);
+    expect(renamed?.firstSeenRevisionId).toBe(1);
+  });
+
+  it("sorts lineages by section name", () => {
+    const revisions = [
+      { revId: 1, timestamp: "2024-01-01T00:00:00Z", content: "Lead\n\n== Z ==\nZ content\n\n== A ==\nA content" },
+    ];
+
+    const lineage = buildSectionLineage(revisions);
+    expect(lineage[0].sectionName).toBe("(lead)");
+    expect(lineage[1].sectionName).toBe("A");
+    expect(lineage[2].sectionName).toBe("Z");
+  });
+});
+
+describe("extractSections", () => {
+  it("extracts lead section when no headers", () => {
+    const sections = sectionDiffer.extractSections("Plain text content.");
+    expect(sections).toHaveLength(1);
+    expect(sections[0].title).toBe("");
+  });
+
+  it("extracts sections with headers", () => {
+    const wikitext = "Lead\n\n== History ==\nOld history\n\n== References ==\n{{reflist}}";
+    const sections = sectionDiffer.extractSections(wikitext);
+    expect(sections.length).toBeGreaterThanOrEqual(3);
+    const history = sections.find((s) => s.title === "History");
+    expect(history).toBeDefined();
+    expect(history?.content).toContain("Old history");
+  });
+
+  it("parses heading levels", () => {
+    const wikitext = "Lead\n\n== Level 2 ==\nContent\n\n=== Level 3 ===\nDeeper";
+    const sections = sectionDiffer.extractSections(wikitext);
+    const level3 = sections.find((s) => s.title === "Level 3");
+    expect(level3).toBeDefined();
+    expect(level3?.level).toBe(3);
+  });
+});
+
+describe("diffSections", () => {
+  it("detects added sections", () => {
+    const before = sectionDiffer.extractSections("Lead content");
+    const after = sectionDiffer.extractSections("Lead content\n\n== New ==\nFresh");
+    const changes = sectionDiffer.diffSections(before, after);
+    const added = changes.find((c) => c.changeType === "added");
+    expect(added).toBeDefined();
+    expect(added?.section).toBe("New");
+  });
+
+  it("detects removed sections", () => {
+    const before = sectionDiffer.extractSections("Lead\n\n== Gone ==\nBye");
+    const after = sectionDiffer.extractSections("Lead");
+    const changes = sectionDiffer.diffSections(before, after);
+    const removed = changes.find((c) => c.changeType === "removed");
+    expect(removed).toBeDefined();
+  });
+
+  it("detects modified sections", () => {
+    const before = sectionDiffer.extractSections("Lead\n\n== Same ==\nOld content");
+    const after = sectionDiffer.extractSections("Lead\n\n== Same ==\nNew content");
+    const changes = sectionDiffer.diffSections(before, after);
+    const modified = changes.find((c) => c.changeType === "modified");
+    expect(modified).toBeDefined();
+  });
+
+  it("marks unchanged sections", () => {
+    const sections = sectionDiffer.extractSections("Lead\n\n== Stable ==\nSame");
+    const changes = sectionDiffer.diffSections(sections, sections);
+    expect(changes.every((c) => c.changeType === "unchanged")).toBe(true);
+  });
+});

package/src/__tests__/talk-activity-detector.test.ts

@@ -0,0 +1,112 @@
+import type { Revision } from "@refract-org/evidence-graph";
+import { describe, expect, it } from "vitest";
+import { detectTalkActivitySpikes } from "../talk-activity-detector.js";
+
+function makeTalkRev(revId: number, timestamp: string): Revision {
+  return { revId, title: "Talk:Test", timestamp, user: "Editor", comment: "talk", content: "" };
+}
+
+function makeArticleRev(revId: number, timestamp: string): Revision {
+  return { revId, title: "Test", timestamp, user: "Editor", comment: "edit", content: "" };
+}
+
+describe("detectTalkActivitySpikes", () => {
+  const today = new Date();
+  function dayOffset(offset: number): string {
+    const d = new Date(today);
+    d.setDate(d.getDate() + offset);
+    return `${d.toISOString().slice(0, 10)}T12:00:00Z`;
+  }
+
+  it("returns empty for no talk revisions", () => {
+    const result = detectTalkActivitySpikes([], [makeArticleRev(1, dayOffset(0))]);
+    expect(result.spikes).toHaveLength(0);
+    expect(result.movingAverage).toBe(0);
+  });
+
+  it("returns empty when insufficient data for moving average", () => {
+    const talkRevs = [makeTalkRev(1, dayOffset(-2)), makeTalkRev(2, dayOffset(-1))];
+    const result = detectTalkActivitySpikes(talkRevs, []);
+    expect(result.spikes).toHaveLength(0);
+    expect(result.activityByDay).toHaveLength(2);
+  });
+
+  it("detects spike when activity exceeds moving average threshold", () => {
+    const talkRevs: Revision[] = [];
+    let id = 1;
+
+    for (let d = 4; d >= 1; d--) {
+      talkRevs.push(makeTalkRev(id++, dayOffset(-d)));
+    }
+
+    // Spike day: 10 edits (exceeds 3x the moving average of ~1)
+    for (let e = 0; e < 10; e++) {
+      talkRevs.push(makeTalkRev(id++, dayOffset(0)));
+    }
+
+    const result = detectTalkActivitySpikes(talkRevs, [], {
+      lookbackWindowMs: 30 * 24 * 60 * 60 * 1000,
+      spikeFactor: 3.0,
+      movingAveragePeriods: 4,
+    });
+
+    expect(result.spikes.length).toBeGreaterThanOrEqual(1);
+    expect(result.spikes[0].eventType).toBe("talk_activity_spike");
+  });
+
+  it("does not flag normal activity as spikes", () => {
+    const talkRevs: Revision[] = [];
+    let id = 1;
+
+    for (let d = 7; d >= 1; d--) {
+      talkRevs.push(makeTalkRev(id++, dayOffset(-d)));
+    }
+
+    const result = detectTalkActivitySpikes(talkRevs, [], {
+      lookbackWindowMs: 30 * 24 * 60 * 60 * 1000,
+      spikeFactor: 3.0,
+      movingAveragePeriods: 4,
+    });
+
+    expect(result.spikes).toHaveLength(0);
+  });
+
+  it("includes nearby article edit count in spike facts", () => {
+    const talkRevs: Revision[] = [];
+    const articleRevs: Revision[] = [];
+    let tid = 1;
+    let aid = 1;
+
+    for (let d = 4; d >= 1; d--) {
+      talkRevs.push(makeTalkRev(tid++, dayOffset(-d)));
+    }
+
+    for (let e = 0; e < 10; e++) {
+      talkRevs.push(makeTalkRev(tid++, dayOffset(0)));
+    }
+    articleRevs.push(makeArticleRev(aid++, dayOffset(0)));
+
+    const result = detectTalkActivitySpikes(talkRevs, articleRevs, {
+      lookbackWindowMs: 30 * 24 * 60 * 60 * 1000,
+      spikeFactor: 3.0,
+      movingAveragePeriods: 4,
+    });
+
+    expect(result.spikes.length).toBeGreaterThanOrEqual(1);
+    expect(result.spikes[0].deterministicFacts[0].detail).toContain("nearby_article_edits=1");
+  });
+
+  it("returns daily activity buckets", () => {
+    const talkRevs: Revision[] = [];
+    let id = 1;
+    talkRevs.push(makeTalkRev(id++, "2024-03-01T00:00:00Z"));
+    talkRevs.push(makeTalkRev(id++, "2024-03-01T12:00:00Z"));
+    talkRevs.push(makeTalkRev(id++, "2024-03-02T00:00:00Z"));
+
+    const result = detectTalkActivitySpikes(talkRevs, []);
+    expect(result.activityByDay).toEqual([
+      { date: "2024-03-01", count: 2 },
+      { date: "2024-03-02", count: 1 },
+    ]);
+  });
+});

package/src/__tests__/talk-correlator.test.ts

@@ -0,0 +1,71 @@
+import type { Revision } from "@refract-org/evidence-graph";
+import { describe, expect, it } from "vitest";
+import { correlateTalkRevisions } from "../talk-correlator.js";
+
+function makeArticleRev(revId: number, daysFromNow: number): Revision {
+  const d = new Date("2026-01-15T12:00:00Z");
+  d.setDate(d.getDate() + daysFromNow);
+  return {
+    revId,
+    pageId: 1,
+    pageTitle: "Test",
+    timestamp: d.toISOString(),
+    comment: "",
+    content: "",
+    size: 100,
+    minor: false,
+  };
+}
+
+function makeTalkRev(revId: number, daysFromNow: number, comment = ""): Revision {
+  const d = new Date("2026-01-15T12:00:00Z");
+  d.setDate(d.getDate() + daysFromNow);
+  return {
+    revId,
+    pageId: 2,
+    pageTitle: "Talk:Test",
+    timestamp: d.toISOString(),
+    comment,
+    content: "",
+    size: 50,
+    minor: false,
+  };
+}
+
+describe("correlateTalkRevisions", () => {
+  it("matches a talk revision within the window", () => {
+    const articleRevs = [makeArticleRev(100, 0)];
+    const talkRevs = [makeTalkRev(200, 1, "discussing source")];
+
+    const events = correlateTalkRevisions(articleRevs, talkRevs);
+    expect(events).toHaveLength(1);
+    expect(events[0].eventType).toBe("talk_page_correlated");
+    expect(events[0].fromRevisionId).toBe(100);
+    expect(events[0].toRevisionId).toBe(200);
+    expect(events[0].deterministicFacts[0].detail).toContain("discussing source");
+  });
+
+  it("does not match a talk revision outside the window", () => {
+    const articleRevs = [makeArticleRev(100, 0)];
+    const talkRevs = [makeTalkRev(200, -20)];
+
+    const events = correlateTalkRevisions(articleRevs, talkRevs);
+    expect(events).toHaveLength(0);
+  });
+
+  it("matches the closest talk revision for each article revision", () => {
+    const articleRevs = [makeArticleRev(100, 0), makeArticleRev(101, 5)];
+    const talkRevs = [makeTalkRev(200, 1), makeTalkRev(201, 2), makeTalkRev(202, 6)];
+
+    const events = correlateTalkRevisions(articleRevs, talkRevs);
+    expect(events).toHaveLength(2);
+    expect(events[0].toRevisionId).toBe(200);
+    expect(events[1].toRevisionId).toBe(202);
+  });
+
+  it("returns empty when either revision list is empty", () => {
+    const rev = makeArticleRev(100, 0);
+    expect(correlateTalkRevisions([], [rev])).toHaveLength(0);
+    expect(correlateTalkRevisions([rev], [])).toHaveLength(0);
+  });
+});

package/src/__tests__/talk-section-parser.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import { buildTalkThreadEvents, diffTalkThreads, parseTalkThreads } from "../talk-section-parser.js";
+
+const SAMPLE_TALK = `
+== Proposal for merger ==
+I propose merging this article with the main one. ~~~~
+: I support this merger. [[User:Alice|Alice]]
+:: I oppose. [[User:Bob|Bob]]
+
+{{resolved}}
+
+== Citation dispute ==
+The third paragraph needs better sources. ~~~~
+: Agreed, I've added a citation. [[User:Charlie|Charlie]]
+`;
+
+const EMPTY_TALK = "This is a talk page with no thread headings.";
+
+describe("parseTalkThreads", () => {
+  it("extracts threads with headings", () => {
+    const threads = parseTalkThreads(SAMPLE_TALK);
+    expect(threads.length).toBeGreaterThanOrEqual(2);
+    expect(threads[0].heading).toBe("Proposal for merger");
+    expect(threads[1].heading).toBe("Citation dispute");
+  });
+
+  it("detects resolved threads", () => {
+    const threads = parseTalkThreads(SAMPLE_TALK);
+    const merger = threads.find((t) => t.heading === "Proposal for merger");
+    expect(merger?.isResolved).toBe(true);
+  });
+
+  it("extracts replies at different depths", () => {
+    const threads = parseTalkThreads(SAMPLE_TALK);
+    const merger = threads.find((t) => t.heading === "Proposal for merger");
+    expect(merger).toBeDefined();
+    expect(merger?.replies.length).toBeGreaterThanOrEqual(3);
+  });
+
+  it("extracts participants from User links", () => {
+    const threads = parseTalkThreads(SAMPLE_TALK);
+    const merger = threads.find((t) => t.heading === "Proposal for merger");
+    expect(merger?.participants.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it("returns empty array for pages with no thread headings", () => {
+    const threads = parseTalkThreads(EMPTY_TALK);
+    expect(Array.isArray(threads)).toBe(true);
+  });
+});
+
+describe("diffTalkThreads", () => {
+  it("detects a new thread as opened", () => {
+    const before = parseTalkThreads("");
+    const after = parseTalkThreads(SAMPLE_TALK);
+
+    const changes = diffTalkThreads(before, after);
+    const opened = changes.filter((c) => c.type === "opened");
+    expect(opened.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("detects a removed thread as archived", () => {
+    const before = parseTalkThreads(SAMPLE_TALK);
+    const after = parseTalkThreads(EMPTY_TALK);
+
+    const changes = diffTalkThreads(before, after);
+    const archived = changes.filter((c) => c.type === "archived");
+    expect(archived.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("detects a reply added to existing thread", () => {
+    const before = parseTalkThreads("== Test ==\nFirst post.");
+    const after = parseTalkThreads("== Test ==\nFirst post.\n: Reply.");
+
+    const changes = diffTalkThreads(before, after);
+    const replyAdded = changes.find((c) => c.type === "reply_added");
+    expect(replyAdded).toBeDefined();
+  });
+});
+
+describe("buildTalkThreadEvents", () => {
+  it("produces talk_thread_opened for new threads", () => {
+    const events = buildTalkThreadEvents("", SAMPLE_TALK, 1, 2, "2026-01-01T00:00:00Z");
+    const opened = events.filter((e) => e.eventType === "talk_thread_opened");
+    expect(opened.length).toBeGreaterThanOrEqual(2);
+    expect(opened[0].fromRevisionId).toBe(1);
+    expect(opened[0].toRevisionId).toBe(2);
+    expect(opened[0].layer).toBe("observed");
+  });
+
+  it("produces talk_thread_archived for removed threads", () => {
+    const events = buildTalkThreadEvents(SAMPLE_TALK, EMPTY_TALK, 1, 2, "2026-01-01T00:00:00Z");
+    const archived = events.filter((e) => e.eventType === "talk_thread_archived");
+    expect(archived.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("produces talk_reply_added for new replies", () => {
+    const before = "== Test ==\nFirst post.";
+    const after = "== Test ==\nFirst post.\n: Reply.";
+
+    const events = buildTalkThreadEvents(before, after, 1, 2, "2026-01-01T00:00:00Z");
+    const replies = events.filter((e) => e.eventType === "talk_reply_added");
+    expect(replies).toHaveLength(1);
+  });
+});

package/src/__tests__/template-tracker.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, it } from "vitest";
+import type { Template } from "../index.js";
+import { buildParamChangeEvents, diffTemplateParams, templateTracker } from "../template-tracker.js";
+
+const TMPL_A: Template = {
+  name: "Infobox character",
+  type: "other",
+  params: { name: "Darth Vader", status: "alive", affiliation: "Sith" },
+};
+
+const TMPL_B: Template = {
+  name: "Infobox character",
+  type: "other",
+  params: { name: "Darth Vader", status: "deceased", affiliation: "Sith" },
+};
+
+const TMPL_C: Template = {
+  name: "Infobox character",
+  type: "other",
+  params: { name: "Darth Vader", status: "deceased", affiliation: "Galactic Empire" },
+};
+
+describe("extractTemplates", () => {
+  it("extracts a simple template", () => {
+    const templates = templateTracker.extractTemplates("{{citation needed}}");
+    expect(templates).toHaveLength(1);
+    expect(templates[0].name).toBe("citation needed");
+    expect(templates[0].type).toBe("citation");
+  });
+
+  it("extracts templates with parameters", () => {
+    const wikitext = "{{Infobox person|name=John|age=30}}";
+    const templates = templateTracker.extractTemplates(wikitext);
+    expect(templates).toHaveLength(1);
+    expect(templates[0].params).toBeDefined();
+    expect(templates[0].params?.name).toBe("John");
+  });
+
+  it("extracts multiple templates", () => {
+    const wikitext = "{{npov}} text {{citation needed}} more {{BLP sources}}";
+    const templates = templateTracker.extractTemplates(wikitext);
+    expect(templates.length).toBeGreaterThanOrEqual(3);
+  });
+
+  it("returns empty for no templates", () => {
+    expect(templateTracker.extractTemplates("Plain text.")).toEqual([]);
+  });
+
+  it("deduplicates identical templates", () => {
+    const templates = templateTracker.extractTemplates("{{foo}}{{foo}}");
+    expect(templates).toHaveLength(1);
+  });
+
+  it("handles nested templates", () => {
+    const wikitext = "{{Infobox|data={{nested}}}}";
+    const templates = templateTracker.extractTemplates(wikitext);
+    expect(templates).toHaveLength(1);
+  });
+});
+
+describe("diffTemplates", () => {
+  it("detects added templates", () => {
+    const before = templateTracker.extractTemplates("plain text");
+    const after = templateTracker.extractTemplates("plain text {{citation needed}}");
+    const changes = templateTracker.diffTemplates(before, after);
+    const added = changes.filter((c) => c.type === "added");
+    expect(added).toHaveLength(1);
+    expect(added[0].template.name).toBe("citation needed");
+  });
+
+  it("detects removed templates", () => {
+    const before = templateTracker.extractTemplates("text {{npov}} more");
+    const after = templateTracker.extractTemplates("text more");
+    const changes = templateTracker.diffTemplates(before, after);
+    expect(changes.filter((c) => c.type === "removed")).toHaveLength(1);
+  });
+
+  it("marks unchanged templates", () => {
+    const before = templateTracker.extractTemplates("text {{citation needed}} more");
+    const after = templateTracker.extractTemplates("text {{citation needed}} more");
+    const changes = templateTracker.diffTemplates(before, after);
+    expect(changes.filter((c) => c.type === "unchanged")).toHaveLength(1);
+  });
+
+  it("handles both added and removed simultaneously", () => {
+    const before = templateTracker.extractTemplates("{{a}} text");
+    const after = templateTracker.extractTemplates("text {{b}}");
+    const changes = templateTracker.diffTemplates(before, after);
+    expect(changes.filter((c) => c.type === "added")).toHaveLength(1);
+    expect(changes.filter((c) => c.type === "removed")).toHaveLength(1);
+  });
+});
+
+describe("diffTemplateParams", () => {
+  it("detects a parameter change", () => {
+    const changes = diffTemplateParams([TMPL_A], [TMPL_B]);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].paramName).toBe("status");
+    expect(changes[0].oldValue).toBe("alive");
+    expect(changes[0].newValue).toBe("deceased");
+  });
+
+  it("detects a parameter added", () => {
+    const before: Template = { name: "Infobox", type: "other", params: { name: "Test" } };
+    const after: Template = { name: "Infobox", type: "other", params: { name: "Test", newParam: "value" } };
+
+    const changes = diffTemplateParams([before], [after]);
+    const added = changes.find((c) => c.paramName === "newparam");
+    expect(added).toBeDefined();
+    expect(added?.oldValue).toBeUndefined();
+    expect(added?.newValue).toBe("value");
+  });
+
+  it("detects a parameter removed", () => {
+    const before: Template = { name: "Infobox", type: "other", params: { name: "Test", oldParam: "value" } };
+    const after: Template = { name: "Infobox", type: "other", params: { name: "Test" } };
+
+    const changes = diffTemplateParams([before], [after]);
+    const removed = changes.find((c) => c.paramName === "oldparam");
+    expect(removed).toBeDefined();
+    expect(removed?.oldValue).toBe("value");
+    expect(removed?.newValue).toBeUndefined();
+  });
+
+  it("returns empty when no params changed", () => {
+    const changes = diffTemplateParams([TMPL_A], [{ ...TMPL_A }]);
+    expect(changes).toHaveLength(0);
+  });
+
+  it("does not process templates not present in both revisions", () => {
+    const different: Template = { name: "Other template", type: "other", params: { x: "y" } };
+    const changes = diffTemplateParams([TMPL_A], [different]);
+    expect(changes).toHaveLength(0);
+  });
+
+  it("normalizes parameter names (lowercase, trimmed)", () => {
+    const before: Template = { name: "Infobox", type: "other", params: { "  Name ": "Old" } };
+    const after: Template = { name: "Infobox", type: "other", params: { name: "New" } };
+
+    const changes = diffTemplateParams([before], [after]);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].paramName).toBe("name");
+    expect(changes[0].oldValue).toBe("Old");
+    expect(changes[0].newValue).toBe("New");
+  });
+});
+
+describe("buildParamChangeEvents", () => {
+  it("produces template_parameter_changed events", () => {
+    const events = buildParamChangeEvents([TMPL_A], [TMPL_C], 1, 2, "2026-01-01T00:00:00Z");
+    expect(events).toHaveLength(2);
+    expect(events[0].eventType).toBe("template_parameter_changed");
+    expect(events[0].fromRevisionId).toBe(1);
+    expect(events[0].toRevisionId).toBe(2);
+    expect(events[0].layer).toBe("observed");
+    const details = events.map((e) => e.deterministicFacts[0].detail ?? "");
+    expect(details.some((d) => d.includes("affiliation"))).toBe(true);
+  });
+});

package/src/__tests__/wikilink-extractor.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+import { buildWikilinkEvents, diffWikilinks, extractWikilinks } from "../wikilink-extractor.js";
+
+describe("extractWikilinks", () => {
+  it("extracts standard wikilinks", () => {
+    const wikitext = "According to [[Fan fiction]] and [[Transformative work]].";
+    const links = extractWikilinks(wikitext);
+    expect(links).toEqual(["fan fiction", "transformative work"]);
+  });
+
+  it("extracts piped wikilinks", () => {
+    const wikitext = "See [[Doctor Who|the Doctor]] for details.";
+    const links = extractWikilinks(wikitext);
+    expect(links).toContain("doctor who");
+  });
+
+  it("returns empty array for no links", () => {
+    const wikitext = "This is plain text without any wikilinks.";
+    const links = extractWikilinks(wikitext);
+    expect(links).toEqual([]);
+  });
+
+  it("skips File: and Image: links", () => {
+    const wikitext = "[[File:photo.jpg]] and [[Image:icon.png]] with [[Foo]].";
+    const links = extractWikilinks(wikitext);
+    expect(links).toEqual(["foo"]);
+  });
+
+  it("skips interwiki links", () => {
+    const wikitext = "See [[wikipedia:Fandom]] for more.";
+    const links = extractWikilinks(wikitext);
+    expect(links).toEqual([]);
+  });
+
+  it("deduplicates identical links", () => {
+    const wikitext = "[[Foo]] and [[foo|bar]] and [[FOO]].";
+    const links = extractWikilinks(wikitext);
+    expect(links).toEqual(["foo"]);
+  });
+
+  it("normalizes underscores to spaces", () => {
+    const wikitext = "[[Fan_fiction]] is a genre.";
+    const links = extractWikilinks(wikitext);
+    expect(links).toContain("fan fiction");
+  });
+});
+
+describe("diffWikilinks", () => {
+  it("detects added links", () => {
+    const { added, removed } = diffWikilinks(["foo", "bar"], ["foo", "bar", "baz"]);
+    expect(added).toEqual(["baz"]);
+    expect(removed).toEqual([]);
+  });
+
+  it("detects removed links", () => {
+    const { added, removed } = diffWikilinks(["foo", "bar", "baz"], ["foo"]);
+    expect(added).toEqual([]);
+    expect(removed).toEqual(["bar", "baz"]);
+  });
+
+  it("detects both added and removed", () => {
+    const { added, removed } = diffWikilinks(["foo", "bar"], ["bar", "baz"]);
+    expect(added).toEqual(["baz"]);
+    expect(removed).toEqual(["foo"]);
+  });
+
+  it("returns empty for no changes", () => {
+    const { added, removed } = diffWikilinks(["foo", "bar"], ["foo", "bar"]);
+    expect(added).toEqual([]);
+    expect(removed).toEqual([]);
+  });
+});
+
+describe("buildWikilinkEvents", () => {
+  it("produces correctly shaped events for added links", () => {
+    const before = "[[Foo]].";
+    const after = "[[Foo]] and [[Bar]].";
+    const events = buildWikilinkEvents(before, after, 1, 2, "body", "2024-01-01T00:00:00Z");
+
+    expect(events.length).toBe(1);
+    expect(events[0].eventType).toBe("wikilink_added");
+    expect(events[0].fromRevisionId).toBe(1);
+    expect(events[0].toRevisionId).toBe(2);
+    expect(events[0].section).toBe("body");
+    expect(events[0].after).toBe("bar");
+    expect(events[0].layer).toBe("observed");
+    expect(events[0].timestamp).toBe("2024-01-01T00:00:00Z");
+  });
+
+  it("produces correctly shaped events for removed links", () => {
+    const before = "[[Foo]] and [[Bar]].";
+    const after = "[[Foo]].";
+    const events = buildWikilinkEvents(before, after, 1, 2, "body", "2024-01-01T00:00:00Z");
+
+    expect(events.length).toBe(1);
+    expect(events[0].eventType).toBe("wikilink_removed");
+    expect(events[0].fromRevisionId).toBe(1);
+    expect(events[0].toRevisionId).toBe(2);
+    expect(events[0].before).toBe("bar");
+  });
+});