infraweaver 0.3.7 → 0.3.8

package/src/utils/unifiedDiff.ts

@@ -0,0 +1,120 @@
+/**
+ * The one unified-diff reader: hunk headers, line classification and per-side
+ * line numbering for every caller that walks a patch — a single GitHub `patch`
+ * fragment (hunks only, no file headers), a truncated review-comment `diff_hunk`,
+ * or a multi-file `git diff`.
+ *
+ * Deliberately TOLERANT, and that is why this is not jsdiff's `parsePatch`: that
+ * one validates every hunk's line counts and throws on a mismatch, but GitHub's
+ * `diff_hunk` is cut off at the commented line by design, and the callers here are
+ * pure functions fed external text where a parse error must not cost the whole
+ * result. Lines are numbered from the hunk header and classified by their marker;
+ * the declared counts are used for exactly one thing (see below).
+ */
+
+/** a parsed `@@ -a,b +c,d @@` header; an omitted count is 1, as git writes it */
+export type HunkHeader = {
+  oldStart: number;
+  oldCount: number;
+  newStart: number;
+  newCount: number;
+};
+
+export type DiffLine =
+  /** a `@@` hunk header */
+  | { kind: "hunk"; raw: string; header: HunkHeader }
+  /** a `+++` new-side file header; `path` has `b/` stripped, `/dev/null` for a deletion */
+  | { kind: "file"; raw: string; path: string }
+  | { kind: "add"; raw: string; text: string; newLine: number }
+  | { kind: "remove"; raw: string; text: string; oldLine: number }
+  | { kind: "context"; raw: string; text: string; oldLine: number; newLine: number }
+  /** anything else: `diff --git`/`---`/`index` headers, ``,
+   *  lines outside any hunk, or an unknown marker — never numbered */
+  | { kind: "meta"; raw: string };
+
+// anchored at line start: an added, removed or context line whose TEXT contains a
+// header-shaped substring (e.g. `+  log.info("@@ -1,2 +3,4 @@")`) is content, not a
+// hunk boundary.
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+
+export function parseHunkHeader(line: string): HunkHeader | null {
+  const m = HUNK_HEADER.exec(line);
+  if (!m) return null;
+  // the start groups are required, so the "" defaults never apply
+  const [, oldS = "", oldC = "1", newS = "", newC = "1"] = m;
+  return {
+    oldStart: Number.parseInt(oldS, 10),
+    oldCount: Number.parseInt(oldC, 10),
+    newStart: Number.parseInt(newS, 10),
+    newCount: Number.parseInt(newC, 10),
+  };
+}
+
+/**
+ * Classify and number every line of `diff`.
+ *
+ * `--- `/`+++ ` are file headers only OUTSIDE a hunk body: once a hunk's declared
+ * counts are used up (or before any hunk). Inside one they are a removed line
+ * starting `-- ` or an added line starting `++ `, which a marker-only reader would
+ * mistake for the next file. Everything else ignores the counts, so a truncated
+ * hunk or a hand-written one with wrong counts still numbers its lines.
+ *
+ * An empty line inside a hunk is a context line whose single space was stripped,
+ * except the input's LAST line — that is the artefact of a trailing newline.
+ */
+export function parseDiffLines(diff: string): DiffLine[] {
+  const raws = diff.split("\n");
+  const out: DiffLine[] = [];
+  let inHunk = false;
+  let oldLine = 0;
+  let newLine = 0;
+  let oldLeft = 0;
+  let newLeft = 0;
+  for (const [i, raw] of raws.entries()) {
+    const header = parseHunkHeader(raw);
+    if (header) {
+      inHunk = true;
+      oldLine = header.oldStart;
+      newLine = header.newStart;
+      oldLeft = header.oldCount;
+      newLeft = header.newCount;
+      out.push({ kind: "hunk", raw, header });
+      continue;
+    }
+    const bodyExhausted = oldLeft <= 0 && newLeft <= 0;
+    if (raw.startsWith("diff --git ") || (raw.startsWith("--- ") && (!inHunk || bodyExhausted))) {
+      inHunk = false;
+      out.push({ kind: "meta", raw });
+      continue;
+    }
+    if (raw.startsWith("+++ ") && (!inHunk || bodyExhausted)) {
+      inHunk = false;
+      out.push({ kind: "file", raw, path: raw.slice(4).trim().replace(/^b\//, "") });
+      continue;
+    }
+    if (!inHunk) {
+      out.push({ kind: "meta", raw });
+      continue;
+    }
+    const marker = raw === "" && i < raws.length - 1 ? " " : raw[0];
+    const text = raw.slice(1);
+    if (marker === "+") {
+      out.push({ kind: "add", raw, text, newLine });
+      newLine++;
+      newLeft--;
+    } else if (marker === "-") {
+      out.push({ kind: "remove", raw, text, oldLine });
+      oldLine++;
+      oldLeft--;
+    } else if (marker === " ") {
+      out.push({ kind: "context", raw, text, oldLine, newLine });
+      oldLine++;
+      newLine++;
+      oldLeft--;
+      newLeft--;
+    } else {
+      out.push({ kind: "meta", raw });
+    }
+  }
+  return out;
+}