linkedin-studio/scripts/editions/tests/distillate.test.ts

import { describe, test } from "node:test";
import assert from "node:assert/strict";
import { mkdtempSync, rmSync, readFileSync } from "node:fs";
import { join } from "node:path";
import { tmpdir } from "node:os";

import {
  DEFAULT_THRESHOLD,
  appendEntry,
  checkSkeleton,
  defaultDistillatePath,
  emptyDistillate,
  loadDistillate,
  normalizeUnit,
  saveDistillate,
  similarity,
} from "../src/distillate.js";
import { SCHEMA_VERSION } from "../src/types.js";
import type { DistillateEntry } from "../src/types.js";

const tmp = () => mkdtempSync(join(tmpdir(), "editions-"));

const entry = (over: Partial<DistillateEntry> = {}): DistillateEntry => ({
  editionId: "05",
  title: "Da pipelinen brøt sammen",
  lockedAt: "2026-07-20",
  anecdotes: ["Jeg brukte tre uker på å migrere pipeline-en, og halvparten av tiden gikk til testdata."],
  arguments: ["Modellen var ikke problemet — det var dataene ingen hadde ryddet på fem år."],
  hooks: ["De fleste AI-prosjekter dør ikke av dårlig modell. De dør av dårlig data."],
  ...over,
});

describe("series distillate — store", () => {
  test("emptyDistillate carries the schema version, the series and no editions", () => {
    const d = emptyDistillate("seres");
    assert.equal(d.schemaVersion, SCHEMA_VERSION);
    assert.equal(d.series, "seres");
    assert.deepEqual(d.editions, []);
  });

  test("loadDistillate on a missing file returns an empty distillate (never throws)", () => {
    const dir = tmp();
    try {
      const d = loadDistillate(join(dir, "nope.json"), "seres");
      assert.equal(d.series, "seres");
      assert.deepEqual(d.editions, []);
    } finally {
      rmSync(dir, { recursive: true, force: true });
    }
  });

  test("save -> load round-trips an appended edition byte-faithfully", () => {
    const dir = tmp();
    try {
      const path = join(dir, "linkedin", "series-distillate.json");
      const { distillate } = appendEntry(emptyDistillate("seres"), entry());
      saveDistillate(path, distillate);

      const back = loadDistillate(path, "seres");
      assert.equal(back.editions.length, 1);
      assert.deepEqual(back.editions[0], entry());
      assert.equal(back.schemaVersion, SCHEMA_VERSION);
      // trailing newline, like every other store in the plugin
      assert.ok(readFileSync(path, "utf8").endsWith("}\n"));
    } finally {
      rmSync(dir, { recursive: true, force: true });
    }
  });

  test("appendEntry appends a new edition and reports it", () => {
    const res = appendEntry(emptyDistillate("seres"), entry());
    assert.equal(res.appended, true);
    assert.equal(res.replaced, false);
    assert.equal(res.distillate.editions.length, 1);
  });

  test("re-locking the same edition REPLACES it, never duplicates (pivot re-lock)", () => {
    const first = appendEntry(emptyDistillate("seres"), entry());
    const revised = entry({ title: "Da pipelinen brøt sammen (revidert)" });
    const second = appendEntry(first.distillate, revised);

    assert.equal(second.appended, false);
    assert.equal(second.replaced, true);
    assert.equal(second.distillate.editions.length, 1);
    assert.equal(second.distillate.editions[0].title, "Da pipelinen brøt sammen (revidert)");
  });

  test("editions keep insertion order", () => {
    let d = emptyDistillate("seres");
    d = appendEntry(d, entry({ editionId: "03" })).distillate;
    d = appendEntry(d, entry({ editionId: "05" })).distillate;
    d = appendEntry(d, entry({ editionId: "04" })).distillate;
    assert.deepEqual(
      d.editions.map((e) => e.editionId),
      ["03", "05", "04"],
    );
  });

  test("defaultDistillatePath sits beside edition-state in the series root", () => {
    assert.equal(
      defaultDistillatePath("/series/seres"),
      join("/series/seres", "linkedin", "series-distillate.json"),
    );
  });
});

describe("series distillate — similarity (language-agnostic character trigrams)", () => {
  test("normalizeUnit lowercases, strips punctuation and collapses whitespace", () => {
    assert.equal(normalizeUnit("  Hei,   DU — da! "), "hei du da");
  });

  test("identical text scores 1", () => {
    const s = "Vi målte 40 prosent kortere ledetid etter omleggingen.";
    assert.equal(similarity(s, s), 1);
  });

  test("empty input scores 0 instead of dividing by zero", () => {
    assert.equal(similarity("", "noe tekst"), 0);
    assert.equal(similarity("noe tekst", "   "), 0);
  });

  test("similarity is symmetric", () => {
    const a = "Modellen var ikke problemet — det var dataene ingen hadde ryddet på fem år.";
    const b = "Problemet var aldri modellen. Det var fem år med data som ingen hadde ryddet.";
    assert.equal(similarity(a, b), similarity(b, a));
  });

  // The calibration set the threshold is derived from. Paraphrase (the same story
  // retold) must land ABOVE the default; unrelated material and same-topic-different-
  // story must land BELOW it — inflection-heavy Norwegian included, which is why this
  // is character trigrams and not word tokens (a shortened hook paraphrase scores
  // 0.11 on word-Jaccard and would slip through).
  test("paraphrase of the same story clears the default threshold", () => {
    const pairs: Array<[string, string]> = [
      [
        "Jeg brukte tre uker på å migrere pipeline-en, og halvparten av tiden gikk til testdata.",
        "Migreringen av pipelinen tok tre uker, og halve tiden gikk med til testdata.",
      ],
      [
        "Modellen var ikke problemet — det var dataene ingen hadde ryddet på fem år.",
        "Problemet var aldri modellen. Det var fem år med data som ingen hadde ryddet.",
      ],
      [
        "De fleste AI-prosjekter dør ikke av dårlig modell. De dør av dårlig data.",
        "AI-prosjekter dør sjelden av modellen. De dør av dataene.",
      ],
    ];
    for (const [a, b] of pairs) {
      assert.ok(
        similarity(a, b) >= DEFAULT_THRESHOLD,
        `expected paraphrase >= ${DEFAULT_THRESHOLD}, got ${similarity(a, b).toFixed(3)}: ${a}`,
      );
    }
  });

  test("unrelated material and same-topic-different-story stay below the threshold", () => {
    const pairs: Array<[string, string]> = [
      [
        "Jeg brukte tre uker på å migrere pipeline-en, og halvparten av tiden gikk til testdata.",
        "Innkjøpsavdelingen krevde en leverandørgaranti vi ikke kunne gi uten en revisjon.",
      ],
      [
        "De fleste AI-prosjekter dør ikke av dårlig modell. De dør av dårlig data.",
        "Vi har hatt en fast ukentlig gjennomgang av porteføljen siden januar.",
      ],
      [
        // same topic, different measured claim — a NEW edition, not a retread
        "Vi målte 40 prosent kortere ledetid etter omleggingen.",
        "Vi målte 12 prosent høyere treffrate etter at vi byttet embedding-modell.",
      ],
    ];
    for (const [a, b] of pairs) {
      assert.ok(
        similarity(a, b) < DEFAULT_THRESHOLD,
        `expected non-reuse < ${DEFAULT_THRESHOLD}, got ${similarity(a, b).toFixed(3)}: ${a}`,
      );
    }
  });
});

describe("series distillate — skeleton check (Step 2.5)", () => {
  const distillate = appendEntry(emptyDistillate("seres"), entry()).distillate;

  test("an empty distillate is always CLEAR (first edition in a series)", () => {
    const r = checkSkeleton(emptyDistillate("seres"), { hooks: ["hva som helst"] });
    assert.equal(r.verdict, "CLEAR");
    assert.deepEqual(r.hits, []);
    assert.equal(r.comparedAgainst, 0);
  });

  test("fresh material is CLEAR", () => {
    const r = checkSkeleton(distillate, {
      anecdotes: ["Innkjøpsavdelingen krevde en leverandørgaranti vi ikke kunne gi uten en revisjon."],
    });
    assert.equal(r.verdict, "CLEAR");
    assert.deepEqual(r.hits, []);
  });

  test("verbatim reuse is REUSE and names the edition it came from", () => {
    const r = checkSkeleton(distillate, { hooks: [entry().hooks[0]] });
    assert.equal(r.verdict, "REUSE");
    assert.equal(r.hits.length, 1);
    assert.equal(r.hits[0].kind, "hook");
    assert.equal(r.hits[0].editionId, "05");
    assert.equal(r.hits[0].score, 1);
    assert.equal(r.hits[0].matched, entry().hooks[0]);
  });

  test("paraphrased reuse is caught, not just verbatim", () => {
    const r = checkSkeleton(distillate, {
      anecdotes: ["Migreringen av pipelinen tok tre uker, og halve tiden gikk med til testdata."],
    });
    assert.equal(r.verdict, "REUSE");
    assert.equal(r.hits[0].kind, "anecdote");
    assert.ok(r.hits[0].score >= DEFAULT_THRESHOLD);
  });

  test("kinds are compared within kind — a hook is not matched against an anecdote", () => {
    // the anecdote text, offered as a hook: the anecdote bucket must not match it
    const r = checkSkeleton(distillate, { hooks: [entry().anecdotes[0]] });
    assert.equal(r.verdict, "CLEAR");
  });

  test("hits are sorted by score descending", () => {
    let d = emptyDistillate("seres");
    d = appendEntry(d, entry({ editionId: "03", hooks: ["De fleste AI-prosjekter dør ikke av dårlig modell. De dør av dårlig data."] })).distillate;
    d = appendEntry(d, entry({ editionId: "04", hooks: ["AI-prosjekter dør sjelden av modellen. De dør av dataene."], anecdotes: [], arguments: [] })).distillate;

    const r = checkSkeleton(d, { hooks: ["De fleste AI-prosjekter dør ikke av dårlig modell. De dør av dårlig data."] });
    assert.equal(r.verdict, "REUSE");
    assert.ok(r.hits.length >= 2);
    for (let i = 1; i < r.hits.length; i++) {
      assert.ok(r.hits[i - 1].score >= r.hits[i].score, "hits must be sorted by score desc");
    }
    assert.equal(r.hits[0].score, 1);
  });

  test("the threshold is configurable and reported back", () => {
    const strict = checkSkeleton(
      distillate,
      { anecdotes: ["Migreringen av pipelinen tok tre uker, og halve tiden gikk med til testdata."] },
      { threshold: 0.95 },
    );
    assert.equal(strict.verdict, "CLEAR");
    assert.equal(strict.threshold, 0.95);
  });

  test("comparedAgainst reports how many editions the skeleton was checked against", () => {
    let d = emptyDistillate("seres");
    d = appendEntry(d, entry({ editionId: "03" })).distillate;
    d = appendEntry(d, entry({ editionId: "04" })).distillate;
    assert.equal(checkSkeleton(d, { hooks: ["noe helt annet om innkjøp og garantier"] }).comparedAgainst, 2);
  });

  test("an absent bucket on the candidate is not an error", () => {
    const r = checkSkeleton(distillate, {});
    assert.equal(r.verdict, "CLEAR");
    assert.deepEqual(r.hits, []);
  });
});