@refract-org/analyzers 0.2.1

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

@@ -0,0 +1,185 @@
+import { describe, expect, it } from "vitest";
+import { buildSourceId, buildSourceLineage, citationTracker } from "../citation-tracker.js";
+
+describe("citationTracker", () => {
+  it("extracts named refs from wikitext", () => {
+    const wikitext = `Content<ref name="src1">{{cite web |url=https://example.edu/research |title=Research Paper}}</ref>`;
+    const refs = citationTracker.extractCitations(wikitext);
+    expect(refs).toHaveLength(1);
+    expect(refs[0].refName).toBe("src1");
+    expect(refs[0].url).toBe("https://example.edu/research");
+  });
+
+  it("diff detects added citations", () => {
+    const before: Parameters<typeof citationTracker.diffCitations>[0] = [];
+    const after = citationTracker.extractCitations(
+      `Content<ref name="a">{{cite web |url=https://example.edu/a}}</ref>`,
+    );
+    const changes = citationTracker.diffCitations(before, after);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].type).toBe("added");
+  });
+
+  it("diff detects replaced citations", () => {
+    const before = citationTracker.extractCitations(
+      `Content<ref name="x">{{cite web |url=https://example.edu/old}}</ref>`,
+    );
+    const after = citationTracker.extractCitations(
+      `Content<ref name="x">{{cite web |url=https://example.edu/new}}</ref>`,
+    );
+    const changes = citationTracker.diffCitations(before, after);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].type).toBe("replaced");
+  });
+
+  it("diff detects removed citations", () => {
+    const before = citationTracker.extractCitations(
+      `Content<ref name="y">{{cite web |url=https://example.edu/y}}</ref>`,
+    );
+    const after: Parameters<typeof citationTracker.diffCitations>[1] = [];
+    const changes = citationTracker.diffCitations(before, after);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].type).toBe("removed");
+  });
+});
+
+describe("buildSourceId", () => {
+  it("hashes URL when present", () => {
+    const id = buildSourceId({ url: "https://example.edu/doc", raw: "<ref>...</ref>" });
+    expect(id).toMatch(/^[0-9a-f]{16}$/);
+  });
+
+  it("hashes ref:name when no URL", () => {
+    const id = buildSourceId({ refName: "Smith2024", raw: '<ref name="Smith2024"/>' });
+    expect(id).toMatch(/^[0-9a-f]{16}$/);
+  });
+
+  it("hashes raw text when no URL or refName", () => {
+    const id = buildSourceId({ raw: "<ref>Some bare citation</ref>" });
+    expect(id).toMatch(/^[0-9a-f]{16}$/);
+  });
+
+  it("produces deterministic output", () => {
+    const a = buildSourceId({ url: "https://example.edu/doc", raw: "" });
+    const b = buildSourceId({ url: "https://example.edu/doc", raw: "" });
+    expect(a).toBe(b);
+  });
+});
+
+describe("buildSourceLineage", () => {
+  it("builds source records and tracks replacement", () => {
+    const rev1 = {
+      revId: 1,
+      timestamp: "2024-01-01T00:00:00Z",
+      content: `Content<ref name="src1">{{cite web |url=https://example.edu/research |title=Original}}</ref>`,
+    };
+    const rev2 = {
+      revId: 2,
+      timestamp: "2024-01-02T00:00:00Z",
+      content: `Content<ref name="src1">{{cite web |url=https://example.edu/research |title=Original}}</ref>`,
+    };
+
+    const result = buildSourceLineage([rev1, rev2]);
+    expect(result.sources).toHaveLength(1);
+    expect(result.lineage).toHaveLength(0);
+    const src = result.sources[0];
+    expect(src.sourceType).toBe("secondary");
+    expect(src.authority).toBe("high");
+    expect(src.firstSeenRevisionId).toBe(1);
+  });
+
+  it("tracks replacement when named ref changes content", () => {
+    const rev1 = {
+      revId: 1,
+      timestamp: "2024-01-01T00:00:00Z",
+      content: `Content<ref name="x">{{cite web |url=https://example.edu/old}}</ref>`,
+    };
+    const rev2 = {
+      revId: 2,
+      timestamp: "2024-01-02T00:00:00Z",
+      content: `Content<ref name="x">{{cite web |url=https://reuters.com/article |title=New}}</ref>`,
+    };
+
+    const result = buildSourceLineage([rev1, rev2]);
+    expect(result.sources).toHaveLength(2);
+    expect(result.lineage).toHaveLength(1);
+
+    const eduSource = result.sources.find((s) => s.url?.includes("example.edu"));
+    if (!eduSource) throw new Error("Expected edu source to be found");
+    const comSource = result.sources.find((s) => s.url?.includes("reuters.com"));
+    if (!comSource) throw new Error("Expected com source to be found");
+
+    expect(eduSource.sourceType).toBe("secondary");
+    expect(eduSource.authority).toBe("high");
+    expect(comSource.sourceType).toBe("news");
+    expect(comSource.authority).toBe("medium");
+
+    expect(result.lineage[0].sourceId).toBe(eduSource.sourceId);
+    expect(result.lineage[0].replacements).toHaveLength(1);
+    expect(result.lineage[0].replacements[0].replacedById).toBe(comSource.sourceId);
+    expect(result.lineage[0].replacements[0].atRevisionId).toBe(2);
+  });
+
+  it("classifies .gov source as government/high", () => {
+    const refUrl = "https://www.nasa.gov/report";
+    const content = `<ref name="g">{{cite web |url=${refUrl} |title=Report}}</ref>`;
+    const result = buildSourceLineage([{ revId: 1, timestamp: "2024-01-01T00:00:00Z", content }]);
+    const src = result.sources.find((s) => s.url === refUrl);
+    if (!src) throw new Error("Expected source to be found");
+    expect(src.sourceType).toBe("government");
+    expect(src.authority).toBe("high");
+  });
+
+  it("classifies doi.org as academic/medium", () => {
+    const refUrl = "https://doi.org/10.1234/test";
+    const content = `<ref name="d">{{cite journal |url=${refUrl} |title=Study}}</ref>`;
+    const result = buildSourceLineage([{ revId: 1, timestamp: "2024-01-01T00:00:00Z", content }]);
+    const src = result.sources.find((s) => s.url === refUrl);
+    if (!src) throw new Error("Expected source to be found");
+    expect(src.sourceType).toBe("academic");
+    expect(src.authority).toBe("medium");
+  });
+
+  it("classifies unknown URL as unknown/unrated", () => {
+    const refUrl = "https://someblog.example/page";
+    const content = `<ref name="u">{{cite web |url=${refUrl} |title=Blog}}</ref>`;
+    const result = buildSourceLineage([{ revId: 1, timestamp: "2024-01-01T00:00:00Z", content }]);
+    const src = result.sources.find((s) => s.url === refUrl);
+    if (!src) throw new Error("Expected source to be found");
+    expect(src.sourceType).toBe("unknown");
+    expect(src.authority).toBe("unrated");
+  });
+
+  it("tracks removal and sets lastSeenRevisionId", () => {
+    const rev1 = {
+      revId: 1,
+      timestamp: "2024-01-01T00:00:00Z",
+      content: `Content<ref name="a">{{cite web |url=https://example.edu/a}}</ref>`,
+    };
+    const rev2 = {
+      revId: 2,
+      timestamp: "2024-01-02T00:00:00Z",
+      content: "Content without citations",
+    };
+
+    const result = buildSourceLineage([rev1, rev2]);
+    const src = result.sources.find((s) => s.url?.includes("example.edu"));
+    if (!src) throw new Error("Expected source to be found");
+    expect(src.lastSeenRevisionId).toBe(1);
+    expect(src.lastSeenAt).toBe("2024-01-01T00:00:00Z");
+  });
+
+  it("classifies no-url as unknown/unrated", () => {
+    const result = buildSourceLineage([
+      {
+        revId: 1,
+        timestamp: "2024-01-01T00:00:00Z",
+        content: `Content<ref name="nourl">Some citation text</ref>`,
+      },
+    ]);
+    const src = result.sources[0];
+    expect(src.url).toBeUndefined();
+    expect(src.sourceType).toBe("unknown");
+    expect(src.authority).toBe("unrated");
+  });
+});

package/src/__tests__/edit-cluster-detector.test.ts

@@ -0,0 +1,79 @@
+import type { Revision } from "@refract-org/evidence-graph";
+import { describe, expect, it } from "vitest";
+import { detectEditClusters } from "../edit-cluster-detector.js";
+
+function makeRev(revId: number, timestamp: string, user?: string): Revision {
+  return {
+    revId,
+    title: "Test Page",
+    timestamp,
+    user: user ?? "Editor",
+    comment: "",
+    content: "",
+  };
+}
+
+describe("detectEditClusters", () => {
+  it("returns empty for fewer than min cluster size revisions", () => {
+    const revs = [makeRev(1, "2024-01-01T00:00:00Z")];
+    const events = detectEditClusters(revs);
+    expect(events).toHaveLength(0);
+  });
+
+  it("detects a cluster of 3 rapid edits within 1 hour", () => {
+    const revs = [
+      makeRev(1, "2024-01-01T00:00:00Z"),
+      makeRev(2, "2024-01-01T00:10:00Z"),
+      makeRev(3, "2024-01-01T00:20:00Z"),
+    ];
+    const events = detectEditClusters(revs, { windowMs: 60 * 60 * 1000 });
+    expect(events).toHaveLength(1);
+    expect(events[0].eventType).toBe("edit_cluster_detected");
+    expect(events[0].fromRevisionId).toBe(1);
+    expect(events[0].toRevisionId).toBe(3);
+  });
+
+  it("does not cluster edits outside the window", () => {
+    const revs = [
+      makeRev(1, "2024-01-01T00:00:00Z"),
+      makeRev(2, "2024-01-01T02:00:00Z"),
+      makeRev(3, "2024-01-01T04:00:00Z"),
+    ];
+    const events = detectEditClusters(revs, { windowMs: 60 * 60 * 1000 });
+    expect(events).toHaveLength(0);
+  });
+
+  it("detects single-editor cluster", () => {
+    const revs = [
+      makeRev(1, "2024-01-01T00:00:00Z", "Alice"),
+      makeRev(2, "2024-01-01T00:05:00Z", "Alice"),
+      makeRev(3, "2024-01-01T00:10:00Z", "Alice"),
+    ];
+    const events = detectEditClusters(revs, { windowMs: 60 * 60 * 1000 });
+    expect(events).toHaveLength(1);
+    expect(events[0].deterministicFacts[0].detail).toContain("single_editor=true");
+  });
+
+  it("detects multi-editor cluster", () => {
+    const revs = [
+      makeRev(1, "2024-01-01T00:00:00Z", "Alice"),
+      makeRev(2, "2024-01-01T00:05:00Z", "Bob"),
+      makeRev(3, "2024-01-01T00:10:00Z", "Charlie"),
+    ];
+    const events = detectEditClusters(revs, { windowMs: 60 * 60 * 1000 });
+    expect(events).toHaveLength(1);
+    expect(events[0].deterministicFacts[0].detail).toContain("single_editor=false");
+  });
+
+  it("respects custom min cluster size", () => {
+    const revs = [
+      makeRev(1, "2024-01-01T00:00:00Z"),
+      makeRev(2, "2024-01-01T00:01:00Z"),
+      makeRev(3, "2024-01-01T00:02:00Z"),
+      makeRev(4, "2024-01-01T00:03:00Z"),
+      makeRev(5, "2024-01-01T00:04:00Z"),
+    ];
+    const events = detectEditClusters(revs, { minClusterSize: 5, windowMs: 60 * 60 * 1000 });
+    expect(events).toHaveLength(1);
+  });
+});

package/src/__tests__/heuristic-classifier.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest";
+import { classifyHeuristic } from "../heuristic-classifier.js";
+
+describe("classifyHeuristic", () => {
+  it("classifies revert patterns in comment", () => {
+    expect(classifyHeuristic("reverted edit", 100)).toBe("revert");
+    expect(classifyHeuristic("Undid revision 12345", 50)).toBe("revert");
+    expect(classifyHeuristic("Rollback vandalism", -300)).toBe("revert");
+    expect(classifyHeuristic("rvv nonsense", 0)).toBe("revert");
+  });
+
+  it("prioritizes revert over vandalism when both match", () => {
+    expect(classifyHeuristic("Revert vandalism", -500)).toBe("revert");
+  });
+
+  it("classifies vandalism patterns in comment", () => {
+    expect(classifyHeuristic("vandal", 100)).toBe("vandalism");
+    expect(classifyHeuristic("spam removal", -200)).toBe("vandalism");
+    expect(classifyHeuristic("blanking section", -1000)).toBe("vandalism");
+    expect(classifyHeuristic("test edit", 10)).toBe("vandalism");
+  });
+
+  it("classifies sourcing patterns in comment", () => {
+    expect(classifyHeuristic("added citation", 500)).toBe("sourcing");
+    expect(classifyHeuristic("add ref", 100)).toBe("sourcing");
+    expect(classifyHeuristic("rm bad source", -200)).toBe("sourcing");
+    expect(classifyHeuristic("cite web", 0)).toBe("sourcing");
+  });
+
+  it("classifies major additions by size", () => {
+    expect(classifyHeuristic("update", 2500)).toBe("major_addition");
+    expect(classifyHeuristic("expanded section", 5000)).toBe("major_addition");
+  });
+
+  it("classifies major removals by size", () => {
+    expect(classifyHeuristic("trim", -2500)).toBe("major_removal");
+    expect(classifyHeuristic("cleanup", -10000)).toBe("major_removal");
+  });
+
+  it("classifies cosmetic edits (small delta, empty comment)", () => {
+    expect(classifyHeuristic("", 10)).toBe("cosmetic");
+    expect(classifyHeuristic("", 0)).toBe("cosmetic");
+    expect(classifyHeuristic("", 19)).toBe("cosmetic");
+  });
+
+  it("classifies minor edits by size delta", () => {
+    expect(classifyHeuristic("fix typo", 50)).toBe("minor");
+    expect(classifyHeuristic("tweak", 99)).toBe("minor");
+  });
+
+  it("returns unknown for unmatched edits", () => {
+    expect(classifyHeuristic("meaningful edit", 500)).toBe("unknown");
+    expect(classifyHeuristic("", 1000)).toBe("unknown");
+  });
+
+  it("respects custom thresholds", () => {
+    expect(classifyHeuristic("big edit", 1500, { majorAdditionThreshold: 1000 })).toBe("major_addition");
+    expect(classifyHeuristic("", 50, { cosmeticThreshold: 100 })).toBe("cosmetic");
+    expect(classifyHeuristic("tweak", 200, { minorThreshold: 300 })).toBe("minor");
+  });
+
+  it("is case-insensitive for comment matching", () => {
+    expect(classifyHeuristic("REVERT", 0)).toBe("revert");
+    expect(classifyHeuristic("CITATION ADDED", 100)).toBe("sourcing");
+    expect(classifyHeuristic("VANDAL", 0)).toBe("vandalism");
+  });
+});

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

@@ -0,0 +1,58 @@
+import type { EvidenceEvent } from "@refract-org/evidence-graph";
+import { describe, expect, it } from "vitest";
+import { diffObservations } from "../observation-differ.js";
+
+function makeEvent(eventType: string, fromRevId: number, toRevId: number, section = "body"): EvidenceEvent {
+  return {
+    eventType: eventType as EvidenceEvent["eventType"],
+    fromRevisionId: fromRevId,
+    toRevisionId: toRevId,
+    section,
+    before: "",
+    after: "",
+    deterministicFacts: [],
+    layer: "observed",
+    timestamp: "2026-01-01T00:00:00Z",
+  };
+}
+
+describe("diffObservations", () => {
+  it("returns zero delta for identical streams", () => {
+    const prior = [makeEvent("revert_detected", 1, 2)];
+    const current = [makeEvent("revert_detected", 1, 2)];
+
+    const diff = diffObservations(prior, current);
+    expect(diff.new).toHaveLength(0);
+    expect(diff.resolved).toHaveLength(0);
+    expect(diff.unchanged).toHaveLength(1);
+  });
+
+  it("detects new events in current stream", () => {
+    const prior = [makeEvent("revert_detected", 1, 2)];
+    const current = [makeEvent("revert_detected", 1, 2), makeEvent("citation_added", 2, 3)];
+
+    const diff = diffObservations(prior, current);
+    expect(diff.new).toHaveLength(1);
+    expect(diff.new[0].eventType).toBe("citation_added");
+    expect(diff.resolved).toHaveLength(0);
+  });
+
+  it("detects resolved events when prior has them and current does not", () => {
+    const prior = [makeEvent("revert_detected", 1, 2), makeEvent("template_added", 2, 3)];
+    const current = [makeEvent("revert_detected", 1, 2)];
+
+    const diff = diffObservations(prior, current);
+    expect(diff.resolved).toHaveLength(1);
+    expect(diff.resolved[0].eventType).toBe("template_added");
+    expect(diff.new).toHaveLength(0);
+  });
+
+  it("handles empty prior stream (first run)", () => {
+    const current = [makeEvent("revert_detected", 1, 2)];
+
+    const diff = diffObservations([], current);
+    expect(diff.new).toHaveLength(1);
+    expect(diff.resolved).toHaveLength(0);
+    expect(diff.unchanged).toHaveLength(0);
+  });
+});

package/src/__tests__/page-move-detector.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { buildPageMoveEvents } from "../page-move-detector.js";
+
+interface MoveRecord {
+  oldTitle: string;
+  newTitle: string;
+  timestamp: string;
+  revId: number;
+  comment: string;
+}
+
+describe("buildPageMoveEvents", () => {
+  it("converts move records to EvidenceEvent[]", () => {
+    const moves: MoveRecord[] = [
+      {
+        oldTitle: "Old Page",
+        newTitle: "New Page",
+        timestamp: "2024-01-01T00:00:00Z",
+        revId: 12345,
+        comment: "Renamed for clarity",
+      },
+    ];
+
+    const events = buildPageMoveEvents(moves);
+
+    expect(events).toHaveLength(1);
+    expect(events[0].eventType).toBe("page_moved");
+    expect(events[0].fromRevisionId).toBe(0);
+    expect(events[0].toRevisionId).toBe(12345);
+    expect(events[0].before).toBe("Old Page");
+    expect(events[0].after).toBe("New Page");
+    expect(events[0].section).toBe("");
+    expect(events[0].layer).toBe("observed");
+    expect(events[0].timestamp).toBe("2024-01-01T00:00:00Z");
+    expect(events[0].deterministicFacts[0].fact).toBe("page_moved");
+  });
+
+  it("handles empty moves", () => {
+    const events = buildPageMoveEvents([]);
+    expect(events).toEqual([]);
+  });
+
+  it("handles multiple moves", () => {
+    const moves: MoveRecord[] = [
+      {
+        oldTitle: "Page A",
+        newTitle: "Page B",
+        timestamp: "2024-01-01T00:00:00Z",
+        revId: 1,
+        comment: "First move",
+      },
+      {
+        oldTitle: "Page B",
+        newTitle: "Page C",
+        timestamp: "2024-01-02T00:00:00Z",
+        revId: 2,
+        comment: "Second move",
+      },
+    ];
+
+    const events = buildPageMoveEvents(moves);
+    expect(events).toHaveLength(2);
+  });
+});

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

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import type { ProtectionLogRecord } from "../protection-tracker.js";
+import { protectionTracker } from "../protection-tracker.js";
+
+describe("protectionTracker", () => {
+  describe("buildState", () => {
+    it("builds state from a protection log", () => {
+      const logs: ProtectionLogRecord[] = [
+        { logId: 1, pageTitle: "Test", timestamp: "2026-01-01T00:00:00Z", comment: "protecting", action: "protect" },
+      ];
+      const state = protectionTracker.buildState(logs);
+      expect(state.size).toBeGreaterThan(0);
+    });
+
+    it("returns empty map for empty logs", () => {
+      const state = protectionTracker.buildState([]);
+      expect(state.size).toBe(0);
+    });
+  });
+
+  describe("diffState", () => {
+    it("detects added protections", () => {
+      const before = new Map();
+      const after = new Map();
+      after.set("Test", { level: "semi", sinceTimestamp: "2026-01-01T00:00:00Z", sinceLogId: 1 });
+
+      const changes = protectionTracker.diffState(before, after);
+      const added = changes.filter((c) => c.type === "added");
+      expect(added.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it("detects removed protections", () => {
+      const before = new Map();
+      before.set("Test", { level: "semi", sinceTimestamp: "2026-01-01T00:00:00Z", sinceLogId: 1 });
+      const after = new Map();
+
+      const changes = protectionTracker.diffState(before, after);
+      const removed = changes.filter((c) => c.type === "removed");
+      expect(removed.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it("returns empty for identical states", () => {
+      const state = new Map();
+      state.set("Test", { level: "semi", sinceTimestamp: "2026-01-01T00:00:00Z", sinceLogId: 1 });
+
+      expect(protectionTracker.diffState(state, state)).toHaveLength(0);
+    });
+  });
+
+  describe("findLogsBetween", () => {
+    const logs: ProtectionLogRecord[] = [
+      { logId: 1, pageTitle: "Test", timestamp: "2026-01-01T00:00:00Z", comment: "first", action: "protect" },
+      { logId: 2, pageTitle: "Test", timestamp: "2026-01-15T00:00:00Z", comment: "second", action: "modify" },
+      { logId: 3, pageTitle: "Test", timestamp: "2026-02-01T00:00:00Z", comment: "third", action: "unprotect" },
+    ];
+
+    it("finds logs within a time range", () => {
+      const found = protectionTracker.findLogsBetween(logs, "2026-01-10T00:00:00Z", "2026-01-20T00:00:00Z");
+      expect(found).toHaveLength(1);
+      expect(found[0].logId).toBe(2);
+    });
+
+    it("returns empty for range with no logs", () => {
+      const found = protectionTracker.findLogsBetween(logs, "2025-01-01T00:00:00Z", "2025-12-31T00:00:00Z");
+      expect(found).toHaveLength(0);
+    });
+
+    it("returns empty for empty logs array", () => {
+      expect(protectionTracker.findLogsBetween([], "2026-01-01T00:00:00Z", "2026-02-01T00:00:00Z")).toEqual([]);
+    });
+  });
+});

package/src/__tests__/revert-detector.test.ts

@@ -0,0 +1,76 @@
+import type { Revision } from "@refract-org/evidence-graph";
+import { describe, expect, it } from "vitest";
+import { revertDetector } from "../revert-detector.js";
+
+function makeRev(revId: number, comment: string, content = ""): Revision {
+  return {
+    revId,
+    pageId: 1,
+    pageTitle: "Test",
+    timestamp: new Date(Date.UTC(2026, 0, revId)).toISOString(),
+    comment,
+    content,
+    size: 100,
+    minor: false,
+  };
+}
+
+describe("isRevert", () => {
+  it("detects 'revert' in comment", () => {
+    expect(revertDetector.isRevert("reverted vandalism")).toBe(true);
+  });
+
+  it("detects 'undid revision' in comment", () => {
+    expect(revertDetector.isRevert("Undid revision 12345 by User")).toBe(true);
+  });
+
+  it("detects 'rvv' in comment", () => {
+    expect(revertDetector.isRevert("rvv nonsense")).toBe(true);
+  });
+
+  it("detects 'rollback' in comment", () => {
+    expect(revertDetector.isRevert("Rollback vandalism")).toBe(true);
+  });
+
+  it("detects 'restore' in comment", () => {
+    expect(revertDetector.isRevert("Restore previous version")).toBe(true);
+  });
+
+  it("detects '[[WP:ROLLBACK]]' in comment", () => {
+    expect(revertDetector.isRevert("[[WP:ROLLBACK]] vandalism")).toBe(true);
+  });
+
+  it("returns false for non-revert comments", () => {
+    expect(revertDetector.isRevert("added citation")).toBe(false);
+    expect(revertDetector.isRevert("fixed typo")).toBe(false);
+    expect(revertDetector.isRevert("expanded section")).toBe(false);
+  });
+
+  it("is case-insensitive", () => {
+    expect(revertDetector.isRevert("REVERT")).toBe(true);
+    expect(revertDetector.isRevert("Reverted")).toBe(true);
+  });
+});
+
+describe("detectRevertChain", () => {
+  it("detects a single revert edit", () => {
+    const revs = [makeRev(1, "added content"), makeRev(2, "reverted")];
+    const chains = revertDetector.detectRevertChain(revs);
+    expect(chains.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it("returns empty for no reverts", () => {
+    const revs = [makeRev(1, "added content"), makeRev(2, "fixed typo"), makeRev(3, "expanded")];
+    expect(revertDetector.detectRevertChain(revs)).toEqual([]);
+  });
+
+  it("detects a multi-edit revert chain", () => {
+    const revs = [makeRev(1, "good edit"), makeRev(2, "revert"), makeRev(3, "re-revert")];
+    const chains = revertDetector.detectRevertChain(revs);
+    expect(chains.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it("returns empty for empty revision list", () => {
+    expect(revertDetector.detectRevertChain([])).toEqual([]);
+  });
+});