pi-supernova 0.0.15 → 0.2.0

package/ledger.js

@@ -1,13 +1,3 @@
-// Seen-ledger: the model's context window is a memory. Nothing that already reached the
-// model in this session is sent again verbatim. A run of identical lines (≥ MIN_RUN, with
-// enough substantive lines) collapses to one marker that cites the earlier program and,
-// when the lines came from a file, path:a–b, so one read(path, a, n) recovers them.
-//
-// This is not compression: every collapsed line already exists, verbatim, in the model's
-// context. Changed lines are never collapsed, so a re-read after an edit shows exactly the
-// delta. Lines the current program read with an explicit offset/limit are pinned and always
-// shown: that is the model asking for a specific window on purpose.
-
 const MIN_RUN = 6;
 const MIN_SUBSTANTIVE = 4;
 const MAX_CANDIDATES = 8;
@@ -15,136 +5,118 @@ const DEFAULT_WINDOW = 40;
 const MAX_STORED_LINES = 200_000;
 
 function hashLine(line) {
-  let h = 0x811c9dc5;
-  for (let i = 0; i < line.length; i++) {
-    h ^= line.charCodeAt(i);
-    h = Math.imul(h, 0x01000193);
-  }
-  return h >>> 0;
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < line.length; i++) hash = Math.imul(hash ^ line.charCodeAt(i), 0x01000193);
+  return hash >>> 0;
 }
-
-function substantive(line) {
-  return line.trim().length >= 8;
+function substantive(line) { return line.trim().length >= 8; }
+function newHistory() {
+  return { results: new Map(), occurrences: new Map(), storedLines: 0, latestCall: 0,
+    stats: { programs: 0, returnedChars: 0, collapsedChars: 0, collapsedRuns: 0 } };
 }
 
 export class SeenLedger {
-  constructor({ window = DEFAULT_WINDOW } = {}) {
+  constructor({ window = DEFAULT_WINDOW, history } = {}) {
     this.window = window;
-    this.results = new Map(); // call → { hashes: Uint32Array, lines: string[] }
-    this.occurrences = new Map(); // hash → [{ call, index }]
-    this.origins = new Map(); // hash → { path, line }  (provenance recorded by the bridge)
-    this.pinned = new Set(); // "path:line" pinned by the current program
-    this.storedLines = 0;
-    this.stats = { programs: 0, returnedChars: 0, collapsedChars: 0, collapsedRuns: 0 };
+    this.history = history ?? newHistory();
+    this.origins = new Map();
+    this.pinned = new Set();
   }
+  get results() { return this.history.results; }
+  get occurrences() { return this.history.occurrences; }
+  get storedLines() { return this.history.storedLines; }
+  get stats() { return this.history.stats; }
+  fork() { return new SeenLedger({ window: this.window, history: this.history }); }
 
   reset() {
-    this.results.clear();
-    this.occurrences.clear();
+    Object.assign(this.history, newHistory());
     this.origins.clear();
     this.pinned.clear();
-    this.storedLines = 0;
-    this.stats = { programs: 0, returnedChars: 0, collapsedChars: 0, collapsedRuns: 0 };
   }
 
   beginProgram(call) {
+    this.origins.clear();
     this.pinned.clear();
     this.stats.programs++;
-    for (const old of [...this.results.keys()]) {
-      if (old <= call - this.window) this.forget(old);
-    }
+    this.history.latestCall = Math.max(this.history.latestCall, call);
+    for (const old of this.results.keys()) if (old <= this.history.latestCall - this.window) this.forget(old);
   }
 
   forget(call) {
     const entry = this.results.get(call);
     if (!entry) return;
-    for (let i = 0; i < entry.hashes.length; i++) {
-      const list = this.occurrences.get(entry.hashes[i]);
-      if (!list) continue;
-      const kept = list.filter((o) => o.call !== call);
-      if (kept.length) this.occurrences.set(entry.hashes[i], kept);
-      else this.occurrences.delete(entry.hashes[i]);
+    for (const hash of new Set(entry.hashes)) {
+      const kept = (this.occurrences.get(hash) ?? []).filter(item => item.call !== call);
+      if (kept.length) this.occurrences.set(hash, kept);
+      else this.occurrences.delete(hash);
     }
-    this.storedLines -= entry.hashes.length;
+    this.history.storedLines -= entry.lines.length;
     this.results.delete(call);
   }
 
-  /** Provenance for lines the bridge is about to hand to the program: file text, outlines, evidence spans. */
   recordOrigin(path, firstLine, lines, pin = false) {
+    if (this.window === 0) return;
     for (let i = 0; i < lines.length; i++) {
-      if (!substantive(lines[i])) continue;
-      this.origins.set(hashLine(lines[i]), { path, line: firstLine + i });
-      if (pin) this.pinned.add(path + ":" + (firstLine + i));
+      const text = lines[i];
+      if (!substantive(text)) continue;
+      if (this.origins.size >= MAX_STORED_LINES && !this.origins.has(text)) this.origins.delete(this.origins.keys().next().value);
+      this.origins.set(text, { path, line: firstLine + i });
+      if (pin) this.pinned.add(text);
     }
   }
 
-  isPinned(hash) {
-    const o = this.origins.get(hash);
-    return o !== undefined && this.pinned.has(o.path + ":" + o.line);
-  }
-
-  /** Length of the identical run between lines[i…] and earlier result `cand`, stopping at pinned lines. */
-  runLength(hashes, cand, i) {
-    const earlier = this.results.get(cand.call);
+  runLength(lines, hashes, candidate, index) {
+    const earlier = this.results.get(candidate.call);
     if (!earlier) return 0;
-    let k = 0;
-    while (i + k < hashes.length && cand.index + k < earlier.hashes.length && earlier.hashes[cand.index + k] === hashes[i + k] && !this.isPinned(hashes[i + k])) k++;
-    return k;
+    let count = 0;
+    while (index + count < lines.length && candidate.index + count < earlier.lines.length
+      && hashes[index + count] === earlier.hashes[candidate.index + count]
+      && lines[index + count] === earlier.lines[candidate.index + count]
+      && !this.pinned.has(lines[index + count])) count++;
+    return count;
   }
 
-  /** Longest earlier run starting at lines[i]; null when shorter than MIN_RUN or not substantive enough. */
-  longestRun(hashes, lines, i) {
-    const candidates = this.occurrences.get(hashes[i]);
+  longestRun(lines, hashes, index, call) {
+    const candidates = this.occurrences.get(hashes[index]);
     if (!candidates) return null;
     let best = null;
-    for (const cand of candidates.slice(-MAX_CANDIDATES)) {
-      const length = this.runLength(hashes, cand, i);
-      if (length >= MIN_RUN && (!best || length > best.length)) best = { call: cand.call, index: cand.index, length };
+    for (const candidate of candidates.filter(item => item.call < call).slice(-MAX_CANDIDATES)) {
+      const length = this.runLength(lines, hashes, candidate, index);
+      if (length >= MIN_RUN && (!best || length > best.length)) best = { ...candidate, length };
     }
     if (!best) return null;
-    const substantiveCount = lines.slice(i, i + best.length).filter(substantive).length;
-    return substantiveCount >= MIN_SUBSTANTIVE ? best : null;
+    let count = 0;
+    for (let i = index; i < index + best.length; i++) if (substantive(lines[i])) count++;
+    return count >= MIN_SUBSTANTIVE ? best : null;
   }
 
-  /** "path:a–b" when every line of the run has consecutive provenance in one file, else "". */
-  citation(hashes, i, length) {
-    const first = this.origins.get(hashes[i]);
+  citation(lines, index, run) {
+    const earlier = this.results.get(run.call);
+    const origin = offset => this.origins.get(lines[index + offset]) ?? earlier?.origins[run.index + offset];
+    const first = origin(0);
     if (!first) return "";
-    let expectLine = first.line;
-    for (let k = 0; k < length; k++) {
-      const o = this.origins.get(hashes[i + k]);
-      if (o) {
-        if (o.path !== first.path || o.line < expectLine) return "";
-        expectLine = o.line + 1;
-      } else {
-        expectLine++;
-      }
+    let expected = first.line;
+    for (let i = 0; i < run.length; i++) {
+      const item = origin(i);
+      if (item && (item.path !== first.path || item.line !== expected)) return "";
+      expected++;
     }
-    return first.path + ":" + first.line + "–" + (expectLine - 1);
+    return first.path + ":" + first.line + "–" + (expected - 1);
   }
 
-  /**
-   * Collapse runs already shown; returns the text to send and remembers exactly that text as call N.
-   */
   dedupe(text, call) {
-    const lines = text.split("\n");
-    if (lines.length < MIN_RUN) {
+    if (this.window === 0) {
       this.stats.returnedChars += text.length;
-      this.remember(call, lines);
       return text;
     }
-    const hashes = new Uint32Array(lines.length);
-    for (let i = 0; i < lines.length; i++) hashes[i] = hashLine(lines[i]);
+    const lines = text.split("\n");
+    const hashes = Uint32Array.from(lines, hashLine);
     const out = [];
     let collapsedChars = 0;
-    for (let i = 0; i < lines.length; ) {
-      const run = substantive(lines[i]) ? this.longestRun(hashes, lines, i) : null;
-      if (!run) {
-        out.push(lines[i]);
-        i++;
-        continue;
-      }
-      const cite = this.citation(hashes, i, run.length);
+    for (let i = 0; i < lines.length;) {
+      const run = substantive(lines[i]) ? this.longestRun(lines, hashes, i, call) : null;
+      if (!run) { out.push(lines[i++]); continue; }
+      const cite = this.citation(lines, i, run);
       out.push("⋯ " + run.length + " lines same as #" + run.call + (cite ? " · " + cite : "") + " ⋯");
       for (let k = 0; k < run.length; k++) collapsedChars += lines[i + k].length + 1;
       this.stats.collapsedRuns++;
@@ -158,21 +130,21 @@ export class SeenLedger {
   }
 
   remember(call, lines) {
-    if (this.storedLines + lines.length > MAX_STORED_LINES) {
-      for (const old of [...this.results.keys()].sort((a, b) => a - b)) {
-        this.forget(old);
-        if (this.storedLines + lines.length <= MAX_STORED_LINES) break;
-      }
+    if (this.window === 0 || call <= this.history.latestCall - this.window || lines.length > MAX_STORED_LINES) return;
+    if (this.results.has(call)) this.forget(call);
+    for (const old of [...this.results.keys()].sort((a, b) => a - b)) {
+      if (this.storedLines + lines.length <= MAX_STORED_LINES) break;
+      this.forget(old);
     }
-    const hashes = new Uint32Array(lines.length);
+    const hashes = Uint32Array.from(lines, hashLine);
+    const origins = lines.map(line => this.origins.get(line));
     for (let i = 0; i < lines.length; i++) {
-      hashes[i] = hashLine(lines[i]);
       if (!substantive(lines[i])) continue;
       let list = this.occurrences.get(hashes[i]);
       if (!list) this.occurrences.set(hashes[i], (list = []));
       list.push({ call, index: i });
     }
-    this.results.set(call, { hashes });
-    this.storedLines += lines.length;
+    this.results.set(call, { hashes, lines, origins });
+    this.history.storedLines += lines.length;
   }
 }

package/omp-frame.js

@@ -127,7 +127,6 @@ function renderPortableFrame(theme, { header, sections = [], state = "pending",
 	const border = borderPaint(theme, state, borderColor);
 	const bgFn = bgFnForState(theme, state);
 	const h = box.horizontal;
-	const v = box.vertical;
 	const cap = h.repeat(3);
 
 	const paintBar = (leftChar, rightChar, label) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-supernova",
-  "version": "0.0.15",
-  "description": "Dual-host CodeMode for Pi/OMP: progressive tool discovery, result bottleneck, and Amdahl Auto parallel.",
+  "version": "0.2.0",
+  "description": "CodeMode for Pi and OMP: read, write, edit, and bash with source selection and bounded results.",
   "type": "module",
   "author": "AdityaVG13",
   "license": "MIT",
@@ -90,5 +90,9 @@
   "bugs": {
     "url": "https://github.com/AdityaVG13/pi-stack/issues"
   },
-  "homepage": "https://github.com/AdityaVG13/pi-stack/tree/main/packages/pi-supernova#readme"
+  "homepage": "https://github.com/AdityaVG13/pi-stack/tree/main/packages/pi-supernova#readme",
+  "dependencies": {
+    "acorn": "^8.18.0",
+    "string-width": "^8.2.2"
+  }
 }

package/parallel.js

@@ -1,47 +1,55 @@
+import { isFunction } from "./decode.js";
 
-import { isString } from "./decode.js";
-export function isMutatingTool(name, config) {
-  const exact = new Set(config.mutatingTools || []);
-  if (exact.has(name)) return true;
-  const prefixes = config.mutatingPrefixes || [];
-  for (const prefix of prefixes) {
-    if (isString(prefix) && prefix.length > 0 && name.startsWith(prefix)) return true;
+const READ_ONLY_TOOLS = new Set(["read", "grep", "glob", "find", "ls", "snap", "evidence", "surface", "asgrep_search", "asgrep_status", "ast_grep", "web_search"]);
+const READ_ONLY_LSP = new Set(["definition", "references", "hover", "symbols", "diagnostics", "implementation", "type_definition", "incoming_calls", "outgoing_calls"]);
+
+export function isMutatingTool(name, config = {}, args = {}, definition) {
+  if ((config.mutatingTools ?? []).includes(name)) return true;
+  if ((config.mutatingPrefixes ?? []).some(prefix => prefix && name.startsWith(prefix))) return true;
+  if (definition?.annotations?.readOnlyHint === true) return false;
+  if (name === "lsp") {
+    const action = args.action ?? args.operation;
+    if (READ_ONLY_LSP.has(action)) return false;
+    if (["rename", "rename_file"].includes(action)) return args.apply !== false;
+    if (action === "code_actions") return args.apply === true;
+    return true;
   }
-  return false;
-}
-async function runSerial(list) {
-  const out = [];
-  for (const thunk of list) out.push(await thunk());
-  return out;
+  if (name === "todo") return args.op !== "view";
+  if (name === "hub") return !["list", "ps", "logs", "describe"].includes(args.op);
+  return !READ_ONLY_TOOLS.has(name);
 }
-function shouldParallelize(mode, anyMutating, count) {
-  if (mode === "parallel") return true;
-  if (mode !== "auto") return false;
-  if (anyMutating) return false;
-  return count > 1;
+
+function requireArray(value, name) {
+  if (!Array.isArray(value)) throw new TypeError(name + " requires an array");
+  return value;
 }
+
 export async function runParallelWave(thunks, meta, options = {}) {
-  const list = Array.isArray(thunks) ? thunks : [];
-  if (list.length === 0) return { results: [], mode: "serial", reason: "empty" };
+  const list = requireArray(thunks, "parallel wave");
+  if (list.some(item => !isFunction(item))) throw new TypeError("parallel wave requires functions");
+  if (!list.length) return { results: [], mode: "serial", reason: "empty" };
   const { mode = "auto", config = {} } = options;
-  const names = Array.isArray(meta?.names) ? meta.names : [];
-  const anyMutating = names.some((n) => isString(n) && isMutatingTool(n, config));
-  if (shouldParallelize(mode, anyMutating, list.length)) {
-    const results = await Promise.all(list.map((thunk) => thunk()));
-    return { results, mode: "parallel", reason: "independent-reads" };
+  const names = meta?.names ?? [];
+  const mutating = names.length !== list.length || names.some((name, i) => isMutatingTool(name, config, meta?.calls?.[i]?.args, meta?.definitions?.[i]));
+  if (!mutating && (mode === "parallel" || (mode === "auto" && list.length > 1))) {
+    // Do not finish a wave while its already-started host calls are still running.
+    const settled = await Promise.allSettled(list.map(thunk => Promise.resolve().then(thunk)));
+    const failure = settled.find(item => item.status === "rejected");
+    if (failure) throw failure.reason;
+    return { results: settled.map(item => item.value), mode: "parallel", reason: "independent-reads" };
   }
-  const results = await runSerial(list);
-  if (anyMutating) return { results, mode: "serial", reason: "mutating" };
-  return { results, mode: "serial", reason: "single-or-forced" };
+  const results = [];
+  for (const thunk of list) results.push(await thunk());
+  return { results, mode: "serial", reason: mutating ? "mutating" : "single-or-forced" };
 }
+
 export async function parallel(items) {
-  const list = Array.isArray(items) ? items : [];
-  return Promise.all(list.map((item) => (item instanceof Function ? item() : item)));
+  return Promise.all(requireArray(items, "parallel").map(item => isFunction(item) ? item() : item));
 }
+
 export async function pipeline(items, ...stages) {
-  let current = Array.isArray(items) ? items.slice() : [];
-  for (const stage of stages) {
-    current = await Promise.all(current.map((item) => stage(item)));
-  }
+  let current = requireArray(items, "pipeline");
+  if (stages.some(stage => !isFunction(stage))) throw new TypeError("pipeline stages must be functions");
+  for (const stage of stages) current = await Promise.all(current.map(item => stage(item)));
   return current;
 }

package/patch.js

@@ -3,104 +3,94 @@ import { isString } from "./decode.js";
 function parseHunkHeader(line) {
   const match = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/.exec(line);
   if (!match) return null;
-  return {
-    oldStart: parseInt(match[1], 10),
-    oldLength: match[2] !== undefined ? parseInt(match[2], 10) : 1,
-    newStart: parseInt(match[3], 10),
-    newLength: match[4] !== undefined ? parseInt(match[4], 10) : 1,
-    lines: [],
-  };
-}
-
-function isHunkLine(line) {
-  return line.startsWith("+") || line.startsWith("-") || line.startsWith(" ");
+  return { oldStart: Number(match[1]), oldLength: match[2] === undefined ? 1 : Number(match[2]),
+    newStart: Number(match[3]), newLength: match[4] === undefined ? 1 : Number(match[4]), lines: [], noNewline: [] };
 }
 
 export function parsePatchHunks(patchText) {
-  const patchLines = patchText.replace(/\r\n/g, "\n").split("\n");
   const hunks = [];
-  let current = null;
-
-  for (const line of patchLines) {
+  let current;
+  let oldCount = 0;
+  let newCount = 0;
+  for (const line of patchText.split("\n")) {
     const header = parseHunkHeader(line);
     if (header) {
-      if (current) hunks.push(current);
       current = header;
-    } else if (current && isHunkLine(line)) {
+      hunks.push(current);
+      oldCount = 0;
+      newCount = 0;
+    } else if (current && line.startsWith("\")) {
+      if (!current.lines.length) throw new Error("newline marker requires a preceding hunk line");
+      current.noNewline.push(current.lines.length - 1);
+    } else if (current && /^[+ -]/.test(line)) {
+      if (oldCount === current.oldLength && newCount === current.newLength && /^--- |^\+\+\+ /.test(line)) {
+        throw new Error("apply_patch accepts one file at a time");
+      }
       current.lines.push(line);
+      if (line[0] !== "+") oldCount++;
+      if (line[0] !== "-") newCount++;
     }
   }
-  if (current) hunks.push(current);
-  if (hunks.length === 0) {
-    throw new Error("no valid patch hunks found (expected @@ -old,len +new,len @@)");
-  }
+  if (!hunks.length) throw new Error("no valid patch hunks found (expected @@ -old,len +new,len @@)");
   return hunks;
 }
 
-function findHunkMatch(fileLines, expectedOld, nominal) {
-  const matchAt = (idx) => {
-    if (idx < 0 || idx + expectedOld.length > fileLines.length) return false;
-    for (let j = 0; j < expectedOld.length; j++) {
-      if (fileLines[idx + j] !== expectedOld[j]) return false;
-    }
-    return true;
-  };
+function splitFile(text) {
+  if (!text) return [];
+  const chunks = text.split("\n");
+  const trailing = chunks.at(-1) === "";
+  if (trailing) chunks.pop();
+  return chunks.map((chunk, index) => {
+    const newline = index < chunks.length - 1 || trailing;
+    const crlf = newline && chunk.endsWith("\r");
+    return { text: crlf ? chunk.slice(0, -1) : chunk, ending: newline ? (crlf ? "\r\n" : "\n") : "" };
+  });
+}
 
+function findHunkMatch(fileLines, expectedOld, nominal) {
+  const matchAt = index => index >= 0 && index + expectedOld.length <= fileLines.length
+    && expectedOld.every((line, i) => fileLines[index + i].text === line);
   if (matchAt(nominal)) return nominal;
-  const maxDelta = Math.max(fileLines.length, 100);
-  for (let delta = 1; delta <= maxDelta; delta++) {
+  if (!expectedOld.length) return -1;
+  for (let delta = 1; delta <= Math.max(fileLines.length, 100); delta++) {
     if (matchAt(nominal + delta)) return nominal + delta;
     if (matchAt(nominal - delta)) return nominal - delta;
   }
   return -1;
 }
 
-function splitHunkLines(hunk) {
-  const expectedOld = [];
-  const newLines = [];
-  for (const hLine of hunk.lines) {
-    if (hLine.startsWith("-")) {
-      expectedOld.push(hLine.slice(1));
-    } else if (hLine.startsWith("+")) {
-      newLines.push(hLine.slice(1));
-    } else {
-      const val = hLine.startsWith(" ") ? hLine.slice(1) : "";
-      expectedOld.push(val);
-      newLines.push(val);
-    }
-  }
-  return { expectedOld, newLines };
-}
-
 export function applyPatchToText(originalText, patchText) {
-  if (!isString(patchText) || !patchText.trim()) {
-    throw new Error("apply_patch requires non-empty patch");
-  }
-
+  if (!isString(patchText) || !patchText.trim()) throw new Error("apply_patch requires non-empty patch");
   const hunks = parsePatchHunks(patchText);
-  let fileLines = originalText.replace(/\r\n/g, "\n").split("\n");
-  const hasTrailingNewline = originalText.endsWith("\n");
+  const fileLines = splitFile(originalText);
+  const ending = fileLines.find(line => line.ending)?.ending ?? "\n";
   let offsetShift = 0;
-
+  let relocationShift = 0;
   for (let h = 0; h < hunks.length; h++) {
     const hunk = hunks[h];
-    const { expectedOld, newLines } = splitHunkLines(hunk);
-
-    if (expectedOld.length !== hunk.oldLength || newLines.length !== hunk.newLength) {
-      throw new Error(`patch hunk ${h + 1} length does not match its header`);
-    }
-
-    const nominal = Math.max(0, hunk.oldStart - 1 + offsetShift);
-    const matchIdx = findHunkMatch(fileLines, expectedOld, nominal);
-    if (matchIdx === -1) {
-      throw new Error(`patch hunk ${h + 1} rejected at line ${hunk.oldStart}: context did not match`);
+    const textOf = line => line.slice(1).replace(/\r$/, "");
+    const expectedOld = hunk.lines.filter(line => line[0] !== "+").map(textOf);
+    const newCount = hunk.lines.filter(line => line[0] !== "-").length;
+    if (expectedOld.length !== hunk.oldLength || newCount !== hunk.newLength) throw new Error("patch hunk " + (h + 1) + " length does not match its header");
+    // The new coordinate also handles BSD diff's -1,0 header at file start.
+    const nominal = hunk.oldLength === 0 ? hunk.newStart - 1 + relocationShift : hunk.oldStart - 1 + offsetShift;
+    const matchIndex = findHunkMatch(fileLines, expectedOld, nominal);
+    if (matchIndex < 0) throw new Error("patch hunk " + (h + 1) + " rejected at line " + hunk.oldStart + ": context did not match");
+    const replacement = [];
+    let oldIndex = matchIndex;
+    for (let i = 0; i < hunk.lines.length; i++) {
+      const line = hunk.lines[i];
+      if (line[0] === "+") {
+        replacement.push({ text: textOf(line), ending: hunk.noNewline.includes(i) ? "" : line.endsWith("\r") ? "\r\n" : ending });
+      } else {
+        const original = fileLines[oldIndex++];
+        if (hunk.noNewline.includes(i) && original.ending) throw new Error("patch newline marker does not match the file");
+        if (line[0] === " ") replacement.push(original);
+      }
     }
-
-    fileLines.splice(matchIdx, expectedOld.length, ...newLines);
-    offsetShift += (matchIdx - nominal) + (newLines.length - expectedOld.length);
+    fileLines.splice(matchIndex, expectedOld.length, ...replacement);
+    relocationShift += matchIndex - nominal;
+    offsetShift += matchIndex - nominal + replacement.length - expectedOld.length;
   }
-
-  let resultText = fileLines.join("\n");
-  if (hasTrailingNewline && !resultText.endsWith("\n")) resultText += "\n";
-  return { resultText, hunkCount: hunks.length };
+  return { resultText: fileLines.map(line => line.text + line.ending).join(""), hunkCount: hunks.length };
 }