@davait/aipictury 1.9.2

package/ext/diff.js

@@ -0,0 +1,150 @@
+'use strict'
+// A line diff for showing what the agent changed in a file, in the panel.
+//
+// Edits are usually local, so the common head and tail are trimmed first; the middle
+// that is left is compared with a longest-common-subsequence table. A middle too large
+// for that table is shown as removed-then-added, which is still correct, only coarser.
+
+const CONTEXT = 3               // unchanged lines shown around each change
+const MAX_TABLE = 4_000_000     // cells in the comparison table before falling back
+const MAX_LINES = 400           // lines shown per diff in the panel
+
+function splitLines(text) {
+  const lines = String(text ?? '').split('\n')
+  if (lines.length && lines[lines.length - 1] === '') lines.pop()
+  return lines
+}
+
+/** The edit script between two texts: [{ op: ' ' | '-' | '+', text, a, b }] where a and b
+ *  are the 1-based line numbers in the old and new text. */
+function lineDiff(before, after) {
+  const a = splitLines(before)
+  const b = splitLines(after)
+  let head = 0
+  while (head < a.length && head < b.length && a[head] === b[head]) head += 1
+  let tail = 0
+  while (tail < a.length - head && tail < b.length - head
+         && a[a.length - 1 - tail] === b[b.length - 1 - tail]) tail += 1
+
+  const midA = a.slice(head, a.length - tail)
+  const midB = b.slice(head, b.length - tail)
+  const out = []
+  for (let i = 0; i < head; i += 1) out.push({ op: ' ', text: a[i], a: i + 1, b: i + 1 })
+
+  if (midA.length * midB.length <= MAX_TABLE) {
+    // lcs[i][j] = length of the common subsequence of midA[i..] and midB[j..]
+    const n = midA.length
+    const m = midB.length
+    const lcs = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1))
+    for (let i = n - 1; i >= 0; i -= 1) {
+      for (let j = m - 1; j >= 0; j -= 1) {
+        lcs[i][j] = midA[i] === midB[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1])
+      }
+    }
+    let i = 0
+    let j = 0
+    while (i < n || j < m) {
+      if (i < n && j < m && midA[i] === midB[j]) {
+        out.push({ op: ' ', text: midA[i], a: head + i + 1, b: head + j + 1 }); i += 1; j += 1
+      } else if (i < n && (j === m || lcs[i + 1][j] >= lcs[i][j + 1])) {
+        // Removals before additions, the way diffs are read.
+        out.push({ op: '-', text: midA[i], a: head + i + 1 }); i += 1
+      } else {
+        out.push({ op: '+', text: midB[j], b: head + j + 1 }); j += 1
+      }
+    }
+  } else {
+    midA.forEach((text, i) => out.push({ op: '-', text, a: head + i + 1 }))
+    midB.forEach((text, j) => out.push({ op: '+', text, b: head + j + 1 }))
+  }
+
+  for (let k = 0; k < tail; k += 1) {
+    const ai = a.length - tail + k
+    const bi = b.length - tail + k
+    out.push({ op: ' ', text: a[ai], a: ai + 1, b: bi + 1 })
+  }
+  return out
+}
+
+/** What the panel draws: only the changed lines and a little context around them,
+ *  with "…" rows where unchanged stretches were skipped. */
+function summarize(before, after) {
+  const script = lineDiff(before, after)
+  const added = script.filter((l) => l.op === '+').length
+  const removed = script.filter((l) => l.op === '-').length
+  const keep = new Array(script.length).fill(false)
+  script.forEach((l, i) => {
+    if (l.op === ' ') return
+    for (let k = Math.max(0, i - CONTEXT); k <= Math.min(script.length - 1, i + CONTEXT); k += 1) keep[k] = true
+  })
+  const lines = []
+  let skipped = false
+  script.forEach((l, i) => {
+    if (keep[i]) {
+      if (skipped) lines.push({ op: '…' })
+      skipped = false
+      lines.push({ op: l.op, text: l.text.slice(0, 400), a: l.a, b: l.b })
+    } else {
+      skipped = true
+    }
+  })
+  const truncated = lines.length > MAX_LINES
+  return { added, removed, created: before === null, lines: lines.slice(0, MAX_LINES), truncated }
+}
+
+/** The changes between two texts as hunks — runs of changed lines — each with its lines,
+ *  for a review that accepts or rejects them one at a time. */
+function hunks(before, after) {
+  const script = lineDiff(before, after)
+  const out = []
+  let current = null
+  script.forEach((l, i) => {
+    if (l.op === ' ') { current = null; return }
+    if (!current) { current = { index: out.length, from: i, removed: [], added: [], line: l.a || l.b }; out.push(current) }
+    if (l.op === '-') current.removed.push(l.text); else current.added.push(l.text)
+    current.to = i
+  })
+  return out
+}
+
+/** `after`, with only the hunks in `keep` applied to `before` — the rest left as they were. */
+function applyHunks(before, after, keep) {
+  const script = lineDiff(before, after)
+  const lines = []
+  let hunk = -1
+  let inHunk = false
+  for (const l of script) {
+    if (l.op === ' ') { inHunk = false; lines.push(l.text); continue }
+    if (!inHunk) { hunk += 1; inHunk = true }
+    const kept = keep.has(hunk)
+    if ((l.op === '+' && kept) || (l.op === '-' && !kept)) lines.push(l.text)
+  }
+  const endsWithNewline = /\n$/.test(keep.size ? after : before) || /\n$/.test(before)
+  return lines.join('\n') + (lines.length && endsWithNewline ? '\n' : '')
+}
+
+/** Where each hunk sits in `after`: { index, start, end } as 0-based line numbers (end is
+ *  start - 1 for a hunk that only removes lines — it sits before line `start`). */
+function hunkRanges(before, after) {
+  const script = lineDiff(before, after)
+  const out = []
+  let current = null
+  for (const l of script) {
+    if (l.op === ' ') {
+      if (current && current.start === undefined) { current.start = l.b - 1; current.end = l.b - 2 }
+      current = null
+      continue
+    }
+    if (!current) { current = { index: out.length }; out.push(current) }
+    if (l.op === '+') {
+      if (current.start === undefined) current.start = l.b - 1
+      current.end = l.b - 1
+    }
+  }
+  // A removal at the very end sits after the last line.
+  const lines = splitLines(after).length
+  for (const h of out) if (h.start === undefined) { h.start = lines; h.end = lines - 1 }
+  return out
+}
+
+module.exports = { lineDiff, summarize, splitLines, hunks, applyHunks, hunkRanges }