@mmerterden/multi-agent-pipeline 20.30.0 → 20.34.0

package/pipeline/scripts/_graph-analysis.mjs

@@ -0,0 +1,270 @@
+/**
+ * @file _graph-analysis.mjs  -  whole-graph views over the code graph.
+ *
+ * File-level structure the per-symbol queries cannot show:
+ *
+ *   importCycles     files that import each other, directly or around a loop
+ *                    (strongly connected components of the file import graph)
+ *   clusters         groups of files more connected to each other than to the
+ *                    rest, by label propagation over imports and references,
+ *                    with a cohesion score (internal / all edges touching it)
+ *   graphDiff        what changed between two builds of the same repository
+ *   questions        a short list of questions worth asking before a change,
+ *                    built from hubs, cycles and the edges between clusters
+ *
+ * Deterministic: same graph in, same answer out, so a report diff means the
+ * code changed. Zero dependencies; the algorithms are small enough to own.
+ *
+ * @module pipeline/scripts/_graph-analysis
+ */
+
+const LP_ROUNDS = 20;
+
+function fileOfSymbolMap(graph) {
+  const fileOf = new Map();
+  for (const e of graph.edges) {
+    if (e.kind === "defines" && e.from.startsWith("file:")) fileOf.set(e.to, e.from);
+  }
+  return fileOf;
+}
+
+/**
+ * Directed file -> file edges: an import of a file, or a reference to a symbol
+ * another file defines. External modules are left out.
+ *
+ * @returns {Map<string, Map<string, {imports: number, references: number}>>}
+ */
+export function fileEdges(graph) {
+  const files = new Set(graph.nodes.filter((n) => n.kind === "file").map((n) => n.id));
+  const fileOf = fileOfSymbolMap(graph);
+  const out = new Map([...files].map((f) => [f, new Map()]));
+  const add = (from, to, kind) => {
+    if (!from || !to || from === to || !files.has(from) || !files.has(to)) return;
+    const row = out.get(from).get(to) ?? { imports: 0, references: 0 };
+    row[kind]++;
+    out.get(from).set(to, row);
+  };
+  for (const e of graph.edges) {
+    const from = files.has(e.from) ? e.from : fileOf.get(e.from);
+    if (e.kind === "imports") add(from, e.to, "imports");
+    else if (e.kind === "references" || e.kind === "inherits") {
+      add(from, files.has(e.to) ? e.to : fileOf.get(e.to), "references");
+    }
+  }
+  return out;
+}
+
+/**
+ * Import cycles: strongly connected components of size two or more of the
+ * file import graph, largest first. Iterative Tarjan, so a deep repository
+ * cannot overflow the stack.
+ *
+ * @returns {string[][]}
+ */
+export function importCycles(graph) {
+  const edges = fileEdges(graph);
+  const succ = (f) => [...edges.get(f)].filter(([, w]) => w.imports > 0).map(([t]) => t);
+  const index = new Map();
+  const low = new Map();
+  const onStack = new Set();
+  const stack = [];
+  const found = [];
+  let next = 0;
+  for (const root of [...edges.keys()].sort()) {
+    if (index.has(root)) continue;
+    const work = [{ id: root, it: 0, nbrs: null }];
+    while (work.length) {
+      const top = work[work.length - 1];
+      if (top.nbrs === null) {
+        index.set(top.id, next);
+        low.set(top.id, next);
+        next++;
+        stack.push(top.id);
+        onStack.add(top.id);
+        top.nbrs = succ(top.id).sort();
+      }
+      if (top.it < top.nbrs.length) {
+        const w = top.nbrs[top.it++];
+        if (!index.has(w)) work.push({ id: w, it: 0, nbrs: null });
+        else if (onStack.has(w)) low.set(top.id, Math.min(low.get(top.id), index.get(w)));
+        continue;
+      }
+      work.pop();
+      if (work.length) {
+        const parent = work[work.length - 1].id;
+        low.set(parent, Math.min(low.get(parent), low.get(top.id)));
+      }
+      if (low.get(top.id) === index.get(top.id)) {
+        const members = [];
+        let m;
+        do {
+          m = stack.pop();
+          onStack.delete(m);
+          members.push(m);
+        } while (m !== top.id);
+        if (members.length > 1) found.push(members.sort());
+      }
+    }
+  }
+  return found.sort((a, b) => b.length - a.length || a[0].localeCompare(b[0]));
+}
+
+/**
+ * Clusters by label propagation on the undirected, weighted file graph. Each
+ * round every file takes the label its neighbours carry the most weight for;
+ * among equal labels the smallest wins, a file keeps its own label on a tie,
+ * and files are visited in id order, so the result does not depend on chance.
+ *
+ * The cluster's id is its most connected file; `dirs` names where its files sit.
+ *
+ * @returns {Array<{id: string, dirs: string, files: string[], cohesion: number, internal: number, external: number}>}
+ */
+export function clusters(graph, { rounds = LP_ROUNDS, minSize = 2 } = {}) {
+  const directed = fileEdges(graph);
+  const nbrs = new Map([...directed.keys()].map((f) => [f, new Map()]));
+  for (const [from, row] of directed) {
+    for (const [to, w] of row) {
+      const weight = w.imports + w.references;
+      nbrs.get(from).set(to, (nbrs.get(from).get(to) ?? 0) + weight);
+      nbrs.get(to).set(from, (nbrs.get(to).get(from) ?? 0) + weight);
+    }
+  }
+  const order = [...nbrs.keys()].sort();
+  const label = new Map(order.map((f) => [f, f]));
+  for (let r = 0; r < rounds; r++) {
+    let changed = false;
+    for (const f of order) {
+      const tally = new Map();
+      for (const [n, w] of nbrs.get(f)) tally.set(label.get(n), (tally.get(label.get(n)) ?? 0) + w);
+      if (!tally.size) continue;
+      let best = null;
+      let bestW = -1;
+      for (const [l, w] of [...tally].sort((a, b) => a[0].localeCompare(b[0]))) {
+        if (w > bestW) {
+          best = l;
+          bestW = w;
+        }
+      }
+      // A file keeps its label on a tie, so one bridge edge cannot pull a
+      // whole group across.
+      if (best !== label.get(f) && bestW > (tally.get(label.get(f)) ?? 0)) {
+        label.set(f, best);
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+  const groups = new Map();
+  for (const f of order) {
+    const l = label.get(f);
+    if (!groups.has(l)) groups.set(l, []);
+    groups.get(l).push(f);
+  }
+  const result = [];
+  for (const files of groups.values()) {
+    if (files.length < minSize) continue;
+    const set = new Set(files);
+    let internal = 0;
+    let external = 0;
+    for (const f of files) {
+      for (const [n, w] of nbrs.get(f)) {
+        if (set.has(n)) internal += w;
+        else external += w;
+      }
+    }
+    internal /= 2;
+    const total = internal + external;
+    const hub = files
+      .map((f) => [f, [...nbrs.get(f)].reduce((sum, [n, w]) => sum + (set.has(n) ? w : 0), 0)])
+      .sort((x, y) => y[1] - x[1] || x[0].localeCompare(y[0]))[0][0];
+    result.push({
+      id: hub.replace(/^file:/, ""),
+      dirs: commonPrefix(files),
+      files,
+      internal,
+      external,
+      cohesion: total ? Math.round((internal / total) * 100) / 100 : 1,
+    });
+  }
+  return result.sort((a, b) => b.files.length - a.files.length || a.id.localeCompare(b.id));
+}
+
+/** A cluster's name: the directory most of its files sit in, and how many others. */
+function commonPrefix(files) {
+  const dirs = new Map();
+  for (const f of files) {
+    const path = f.replace(/^file:/, "");
+    const dir = path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : ".";
+    dirs.set(dir, (dirs.get(dir) ?? 0) + 1);
+  }
+  const ranked = [...dirs].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  return ranked.length > 1 ? `${ranked[0][0]} (+${ranked.length - 1} dirs)` : ranked[0][0];
+}
+
+/** Nodes and edges added and removed between two builds. */
+export function graphDiff(before, after) {
+  const ids = (g, kind) => new Set(g.nodes.filter((n) => n.kind === kind).map((n) => n.id));
+  const edgeKey = (e) => `${e.from}|${e.kind}|${e.to}`;
+  const delta = (a, b) => ({
+    added: [...b].filter((x) => !a.has(x)).sort(),
+    removed: [...a].filter((x) => !b.has(x)).sort(),
+  });
+  const edgesA = new Set(before.edges.map(edgeKey));
+  const edgesB = new Set(after.edges.map(edgeKey));
+  const e = delta(edgesA, edgesB);
+  return {
+    files: delta(ids(before, "file"), ids(after, "file")),
+    symbols: delta(ids(before, "symbol"), ids(after, "symbol")),
+    edges: { added: e.added.length, removed: e.removed.length },
+    cycles: {
+      before: importCycles(before).length,
+      after: importCycles(after).length,
+    },
+  };
+}
+
+/**
+ * Questions worth asking before a change, from what the graph can show:
+ * the widest hubs, each import cycle, and the strongest link between two
+ * clusters. Templates only; no model call.
+ */
+export function questions(graph, { hubs = [], cycles = null, groups = null, max = 8 } = {}) {
+  const out = [];
+  const shortPath = (id) => id.replace(/^file:/, "");
+  for (const h of hubs.slice(0, 3)) {
+    out.push(`What depends on \`${h.name}\` (${h.degree} edges), and which of it has tests?`);
+  }
+  for (const c of (cycles ?? importCycles(graph)).slice(0, 2)) {
+    const shown = c.slice(0, 3).map(shortPath).join("`, `");
+    out.push(
+      `Why do \`${shown}\`${c.length > 3 ? ` and ${c.length - 3} more` : ""} import each other?`,
+    );
+  }
+  const list = groups ?? clusters(graph);
+  const clusterOf = new Map();
+  list.forEach((g, i) => g.files.forEach((f) => clusterOf.set(f, i)));
+  const cross = new Map();
+  for (const [from, row] of fileEdges(graph)) {
+    for (const [to, w] of row) {
+      const a = clusterOf.get(from);
+      const b = clusterOf.get(to);
+      if (a === undefined || b === undefined || a === b) continue;
+      const key = `${a}>${b}`;
+      const cur = cross.get(key) ?? { a, b, weight: 0, via: from };
+      cur.weight += w.imports + w.references;
+      cross.set(key, cur);
+    }
+  }
+  const strongest = [...cross.values()].sort((x, y) => y.weight - x.weight).slice(0, 2);
+  for (const l of strongest) {
+    out.push(
+      `Should the cluster around \`${list[l.a].id}\` reach into the one around \`${list[l.b].id}\` directly (${l.weight} edges, e.g. from \`${shortPath(l.via)}\`)?`,
+    );
+  }
+  for (const g of list.filter((x) => x.files.length >= 3 && x.cohesion < 0.3).slice(0, 2)) {
+    out.push(
+      `The cluster around \`${g.id}\` (${g.dirs}) has cohesion ${g.cohesion}: one module, or several sharing a folder?`,
+    );
+  }
+  return out.slice(0, max);
+}

package/pipeline/scripts/_memory-policy.mjs

@@ -0,0 +1,165 @@
+/**
+ * @file _memory-policy.mjs  -  what the per-repo memory stores may keep, and
+ * how much weight an entry has earned.
+ *
+ *   ledgerRowId(row)       the stable id of a learnings-ledger row, the one
+ *                          feedback is recorded against
+ *   checkedSlug(slug)      the slug as one folder name; a separator, NUL, `.`
+ *                          or `..`, anything that could leave
+ *                          ~/.claude/memory/multi-agent/, throws
+ *   memoryExcluded(slug)   prefs.global.memory.excludeProjects lists repo slugs
+ *                          whose memory is never written; every store asks
+ *                          before it writes
+ *   standing(feedback)     what the outcomes recorded against one ledger entry
+ *                          say about it: suppressed (marked corrected, or
+ *                          judged a dead end more often than useful, twice or
+ *                          more), corroborated (useful at least twice) and a
+ *                          strength that decays with age (ACT-R base level,
+ *                          ln of the sum of age^-0.5 over the useful dates)
+ *   nearDuplicate(a, b)    two statements that say the same thing in other
+ *                          words: TF-IDF cosine at or above the threshold, the
+ *                          same numbers, the same negations and mostly the
+ *                          same word order ("A over B" is not "B over A")
+ *
+ * Zero dependencies.
+ *
+ * @module pipeline/scripts/_memory-policy
+ */
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { shortId, tokens } from "./_retrieval.mjs";
+
+const CORROBORATION = 2;
+const NEAR_DUP = 0.9;
+const ORDER_OVERLAP = 0.5;
+const NEGATIONS = /\b(not|never|no|none|without|except|only|avoid|don't|do not)\b/gi;
+
+function prefs(env) {
+  const p =
+    env.MULTI_AGENT_PREFS || join(env.HOME || homedir(), ".claude", "multi-agent-preferences.json");
+  try {
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+/** Stable id of a ledger row: its kind and its whitespace-folded statement. */
+export function ledgerRowId(row) {
+  const statement = String(row?.statement || "")
+    .toLowerCase()
+    .replace(/\s+/g, " ")
+    .trim();
+  return shortId("L", row?.kind, statement);
+}
+
+/**
+ * The slug, when it names one folder; throws on anything that could leave the
+ * memory folder (a separator, NUL, `.` or `..`). Spaces and non-ASCII letters
+ * are fine: a repository folder may carry them.
+ */
+export function checkedSlug(slug) {
+  const s = String(slug ?? "");
+  if (!s || s.length > 255 || /[/\\\0]/.test(s) || s === "." || s === "..") {
+    throw new Error(`not a repository slug: ${JSON.stringify(s.slice(0, 80))}`);
+  }
+  return s.normalize("NFC");
+}
+
+/** True when the repo's memory must not be written. */
+export function memoryExcluded(slug, env = process.env) {
+  const list = prefs(env)?.global?.memory?.excludeProjects;
+  const want = String(slug ?? "").normalize("NFC");
+  return Array.isArray(list) && list.some((p) => String(p).normalize("NFC") === want);
+}
+
+/**
+ * @param {Array<{ts: string, outcome: string}>} feedback  rows for one entry
+ * @returns {{useful: number, deadEnd: number, corrected: number, suppressed: boolean, corroborated: boolean, strength: number}}
+ */
+export function standing(feedback, now = Date.now()) {
+  const useful = feedback.filter((f) => f.outcome === "useful");
+  const deadEnd = feedback.filter((f) => f.outcome === "dead_end").length;
+  const corrected = feedback.filter((f) => f.outcome === "corrected").length;
+  const sum = useful.reduce((s, f) => {
+    const t = Date.parse(f.ts);
+    const days = Number.isNaN(t) ? 365 : Math.max(0, (now - t) / 86400000);
+    return s + Math.pow(days + 1, -0.5);
+  }, 0);
+  return {
+    useful: useful.length,
+    deadEnd,
+    corrected,
+    suppressed: corrected > 0 || (deadEnd >= CORROBORATION && deadEnd > useful.length),
+    corroborated: useful.length >= CORROBORATION,
+    strength: sum > 0 ? Math.log(sum) + 10 : 0,
+  };
+}
+
+const numbersIn = (s) => (String(s).match(/\d+(?:\.\d+)?/g) || []).sort().join(",");
+const negationsIn = (s) =>
+  (String(s).toLowerCase().match(NEGATIONS) || [])
+    .map((w) => w.replace(/\s+/g, " "))
+    .sort()
+    .join(",");
+
+/** Inverse document frequencies over a corpus of token lists. */
+function idf(corpus) {
+  const df = new Map();
+  for (const doc of corpus) for (const t of new Set(doc)) df.set(t, (df.get(t) || 0) + 1);
+  const n = corpus.length;
+  return (t) => Math.log(1 + n / (df.get(t) || 1));
+}
+
+function tfidf(doc, weight) {
+  const tf = new Map();
+  for (const t of doc) tf.set(t, (tf.get(t) || 0) + 1);
+  const v = new Map();
+  for (const [t, c] of tf) v.set(t, c * weight(t));
+  return v;
+}
+
+function cosine(va, vb) {
+  let dot = 0;
+  for (const [t, w] of va) dot += w * (vb.get(t) || 0);
+  const norm = (v) => Math.sqrt([...v.values()].reduce((s, w) => s + w * w, 0));
+  const d = norm(va) * norm(vb);
+  return d ? dot / d : 0;
+}
+
+/** Jaccard overlap of adjacent token pairs: low when the same words come in another order. */
+function orderOverlap(a, b) {
+  const pairs = (doc) => new Set(doc.slice(1).map((t, i) => `${doc[i]} ${t}`));
+  const pa = pairs(a);
+  const pb = pairs(b);
+  if (!pa.size || !pb.size) return 0;
+  let shared = 0;
+  for (const p of pa) if (pb.has(p)) shared++;
+  return shared / (pa.size + pb.size - shared);
+}
+
+/**
+ * The existing statement `candidate` repeats in other words, or null.
+ *
+ * @param {string} candidate
+ * @param {string[]} existing  statements of the same kind
+ */
+export function nearDuplicate(candidate, existing) {
+  const c = tokens(candidate);
+  if (c.length < 3) return null;
+  const docs = existing.map((s) => tokens(s));
+  const weight = idf([...docs, c]);
+  const vc = tfidf(c, weight);
+  const nums = numbersIn(candidate);
+  const negs = negationsIn(candidate);
+  for (let i = 0; i < existing.length; i++) {
+    if (numbersIn(existing[i]) !== nums) continue;
+    if (negationsIn(existing[i]) !== negs) continue;
+    if (orderOverlap(c, docs[i]) < ORDER_OVERLAP) continue;
+    if (cosine(vc, tfidf(docs[i], weight)) >= NEAR_DUP) return existing[i];
+  }
+  return null;
+}

package/pipeline/scripts/_secret-scan.mjs

@@ -0,0 +1,105 @@
+/**
+ * @file _secret-scan.mjs  -  the check every memory store runs before it writes.
+ *
+ * Text goes to a 0600 temp file and through `pre-commit-check.sh --scan-file`,
+ * which owns the secret patterns; a hit is refused, never written. A store
+ * that cannot find the scanner refuses as well, because "unchecked" and
+ * "clean" are different answers and only one of them may reach a file that
+ * later rides into a prompt.
+ *
+ * `<private>...</private>` spans are removed before the scan, so a caller can
+ * mark text that must not be remembered; an unclosed tag drops everything
+ * after it.
+ *
+ * Control bytes are removed from the scanned copy: the scanner skips a file
+ * `file --mime` calls binary, and one NUL is enough for that verdict. Removing
+ * them also rejoins a token split by one. A run that starts with a known token
+ * prefix is scanned a second time with its inner whitespace removed, so a token
+ * hard-wrapped by a space or a line break is still caught; prose without such
+ * a prefix is scanned once, as written.
+ *
+ * @module pipeline/scripts/_secret-scan
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+// eslint-disable-next-line no-control-regex
+const CONTROL = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
+const WRAPPED_TOKEN =
+  /(?:gh[pousr]_|github_pat_|glpat-|xox[baprs]-|sk-|sk_live_|rk_live_|npm_|hf_|gsk_|pplx-|fig[a-z]_|eyJ|AIza|AKIA|ASIA)[A-Za-z0-9_.-]{0,256}(?:\s+[A-Za-z0-9_.-]{1,256}){1,16}/g;
+
+/** The text with whitespace removed inside every run that starts like a token. */
+function rejoined(text) {
+  return text.replace(WRAPPED_TOKEN, (m) => m.replace(/\s+/g, ""));
+}
+
+/** Remove `<private>` spans; an unclosed opening tag drops the rest. */
+export function stripPrivate(text) {
+  return String(text ?? "")
+    .replace(/<private>[\s\S]*?<\/private>/gi, " ")
+    .replace(/<private>[\s\S]*$/i, " ")
+    .replace(/<\/private>/gi, " ");
+}
+
+function scannerPath() {
+  const local = join(HERE, "pre-commit-check.sh");
+  if (existsSync(local)) return local;
+  const installed = join(homedir(), ".claude", "scripts", "pre-commit-check.sh");
+  return existsSync(installed) ? installed : null;
+}
+
+/**
+ * A scanner bound to one temp directory. `isClean(text)` is true only when
+ * the scanner ran and found nothing; call `close()` when done.
+ */
+export function openScanner() {
+  const scanner = scannerPath();
+  if (!scanner) return { scanned: false, isClean: () => false, close() {} };
+  const dir = mkdtempSync(join(tmpdir(), "secret-scan-"));
+  const file = join(dir, "candidate.txt");
+  return {
+    scanned: true,
+    isClean(text) {
+      const plain = String(text ?? "").replace(CONTROL, "");
+      const copies = [plain];
+      const joined = rejoined(plain);
+      if (joined !== plain) copies.push(joined);
+      return copies.every((copy) => {
+        writeFileSync(file, `${copy}\n`, { mode: 0o600 });
+        try {
+          execFileSync("bash", [scanner, "--scan-file", file], {
+            stdio: "ignore",
+            timeout: 15_000,
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      });
+    },
+    close() {
+      rmSync(dir, { recursive: true, force: true });
+    },
+  };
+}
+
+/** Split items into kept and dropped by the text `textOf(item)` returns. */
+export function dropSecrets(items, textOf) {
+  const scan = openScanner();
+  const kept = [];
+  let dropped = 0;
+  try {
+    for (const it of items) {
+      if (scan.isClean(textOf(it))) kept.push(it);
+      else dropped++;
+    }
+  } finally {
+    scan.close();
+  }
+  return { kept, dropped, scanned: scan.scanned };
+}

package/pipeline/scripts/_spawn-async.mjs

@@ -16,18 +16,20 @@ import { clearTimeout, setTimeout } from "node:timers";
 /**
  * @param {string} cmd
  * @param {string[]} args
- * @param {{env?: object, timeoutMs?: number, maxBytes?: number}} [opts]
+ * @param {{env?: object, timeoutMs?: number, maxBytes?: number, withStderr?: boolean}} [opts]
+ *   withStderr: collect stderr into `stdout` too, for tools that print their
+ *   answer there.
  * @returns {Promise<{status: number|null, stdout: string, timedOut: boolean, truncated: boolean, error: string|null}>}
  */
 export function spawnAsync(
   cmd,
   args,
-  { env = process.env, timeoutMs = 60_000, maxBytes = 32 * 1024 * 1024 } = {},
+  { env = process.env, timeoutMs = 60_000, maxBytes = 32 * 1024 * 1024, withStderr = false } = {},
 ) {
   return new Promise((resolve) => {
     let child;
     try {
-      child = spawn(cmd, args, { env, stdio: ["ignore", "pipe", "ignore"] });
+      child = spawn(cmd, args, { env, stdio: ["ignore", "pipe", withStderr ? "pipe" : "ignore"] });
     } catch (e) {
       resolve({
         status: null,
@@ -47,7 +49,7 @@ export function spawnAsync(
       timedOut = true;
       child.kill("SIGKILL");
     }, timeoutMs);
-    child.stdout.on("data", (d) => {
+    const collect = (d) => {
       size += d.length;
       if (size > maxBytes) {
         truncated = true;
@@ -55,7 +57,9 @@ export function spawnAsync(
         return;
       }
       chunks.push(d);
-    });
+    };
+    child.stdout.on("data", collect);
+    if (withStderr) child.stderr.on("data", collect);
     child.on("error", (e) => {
       error = e.code ?? e.message;
     });

package/pipeline/scripts/_unified-diff.mjs

@@ -10,7 +10,7 @@
 
 /**
  * @typedef {{line: number, text: string}} DiffLine
- * @typedef {{removed: DiffLine[], added: DiffLine[]}} Hunk
+ * @typedef {{header: string, removed: DiffLine[], added: DiffLine[]}} Hunk
  * @typedef {{added: string[], addedAt: DiffLine[], removed: string[], removedAt: DiffLine[],
  *            hunks: Hunk[], isNew: boolean, isDeleted: boolean, binary: boolean}} DiffFile
  */
@@ -73,7 +73,7 @@ export function parseUnifiedDiff(text) {
     let newLeft = h[4] === undefined ? 1 : Number(h[4]);
     let oldNo = Number(h[1]);
     let newNo = Number(h[3]);
-    const hunk = { removed: [], added: [] };
+    const hunk = { header: h[0], removed: [], added: [] };
     cur.hunks.push(hunk);
     while ((oldLeft > 0 || newLeft > 0) && i + 1 < lines.length) {
       const body = lines[++i];