@visual-z/xeno 0.1.0

package/src/tui/diff.ts

@@ -0,0 +1,160 @@
+/**
+ * Line diff for an edit's old/new snippets.
+ *
+ * Ported from pi (earendil-works/pi, MIT) — packages/coding-agent/src/core/tools/edit-diff.ts
+ * `generateDiffString`: context around changed lines, skip the rest. We cannot
+ * take the `diff` package (tui may not import npm), so the hunks are an LCS
+ * of lines rather than Myers. Edits carry snippets, not whole files, so O(n·m)
+ * stays small.
+ *
+ * Why not the whole file: the information in an edit is what changed. Dumping
+ * the destination file fills the live region and makes the user hunt.
+ */
+
+import { PLAIN_ATTRS, paint, type Attrs, type Style } from "./style.ts";
+import { displayWidth } from "./width.ts";
+
+/**
+ * Unchanged lines kept on each side of a hunk. From pi's generateDiffString
+ * default (4). Assumed, not measured: more context drowns the `+`/`-` lines
+ * this view exists to show.
+ */
+const CONTEXT_LINES = 4;
+
+export type DiffOp = { kind: "eq" | "del" | "add"; line: string };
+
+export function diffLines(oldText: string, newText: string): DiffOp[] {
+  const a = oldText.split("\n");
+  const b = newText.split("\n");
+  const n = a.length;
+  const m = b.length;
+  const dp: number[][] = Array.from({ length: n + 1 }, () => Array<number>(m + 1).fill(0));
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      dp[i]![j] = a[i] === b[j] ? dp[i + 1]![j + 1]! + 1 : Math.max(dp[i + 1]![j]!, dp[i]![j + 1]!);
+    }
+  }
+  const out: DiffOp[] = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      out.push({ kind: "eq", line: a[i]! });
+      i++;
+      j++;
+    } else if (dp[i + 1]![j]! >= dp[i]![j + 1]!) {
+      out.push({ kind: "del", line: a[i]! });
+      i++;
+    } else {
+      out.push({ kind: "add", line: b[j]! });
+      j++;
+    }
+  }
+  while (i < n) {
+    out.push({ kind: "del", line: a[i]! });
+    i++;
+  }
+  while (j < m) {
+    out.push({ kind: "add", line: b[j]! });
+    j++;
+  }
+  return out;
+}
+
+/**
+ * Keep only ops within CONTEXT_LINES of a change. Skipped equal runs become
+ * a dim `... (N lines)` so the omission is counted, not silent.
+ */
+export function withContext(ops: readonly DiffOp[]): DiffOp[] {
+  const keep = new Array<boolean>(ops.length).fill(false);
+  for (let i = 0; i < ops.length; i++) {
+    if (ops[i]!.kind === "eq") continue;
+    const from = Math.max(0, i - CONTEXT_LINES);
+    const to = Math.min(ops.length - 1, i + CONTEXT_LINES);
+    for (let k = from; k <= to; k++) keep[k] = true;
+  }
+  const out: DiffOp[] = [];
+  let i = 0;
+  while (i < ops.length) {
+    if (keep[i]) {
+      out.push(ops[i]!);
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j < ops.length && !keep[j]) j++;
+    const skipped = j - i;
+    if (skipped > 0) out.push({ kind: "eq", line: `... (${skipped} lines)` });
+    i = j;
+  }
+  return out;
+}
+
+const DEL: Attrs = { ...PLAIN_ATTRS, red: true };
+const ADD: Attrs = { ...PLAIN_ATTRS, green: true };
+const EQ: Attrs = { ...PLAIN_ATTRS, dim: true };
+
+export function renderDiff(oldText: string, newText: string, width: number, style: Style): string[] {
+  const ops = withContext(diffLines(oldText, newText));
+  const out: string[] = [];
+  for (const op of ops) {
+    const mark = op.kind === "del" ? "-" : op.kind === "add" ? "+" : " ";
+    const attrs = op.kind === "del" ? DEL : op.kind === "add" ? ADD : EQ;
+    out.push(...emitPrefixed(mark, op.line, width, style, attrs));
+  }
+  return out;
+}
+
+/**
+ * Columns left for the body after the prefix. A prefix that does not
+ * leave at least one column is dropped: wrapPlain floors a zero budget
+ * at 1, so keeping the prefix would paint prefixW+1 columns and the
+ * terminal would wrap. The line-diff renderer then counts one row where
+ * the screen used two — the same trap as a 0-column pty (`usableColumns`
+ * in terminal.ts).
+ */
+export function innerWidth(prefix: string, width: number): number {
+  const w = Math.max(0, Math.floor(width));
+  if (w <= 0) return 0;
+  const prefixW = displayWidth(prefix);
+  return prefixW > 0 && prefixW < w ? w - prefixW : w;
+}
+
+export function emitPrefixed(
+  prefix: string,
+  body: string,
+  width: number,
+  style: Style,
+  attrs: Attrs,
+): string[] {
+  const w = Math.max(0, Math.floor(width));
+  if (w <= 0) return [""];
+  const prefixW = displayWidth(prefix);
+  const inner = innerWidth(prefix, w);
+  const rows = wrapPlain(body, inner);
+  if (inner === w) {
+    return rows.map((row) => paint(row, attrs, style));
+  }
+  const pad = " ".repeat(prefixW);
+  return rows.map((row, i) => paint((i === 0 ? prefix : pad) + row, attrs, style));
+}
+
+export function wrapPlain(text: string, width: number): string[] {
+  if (width <= 0) return [""];
+  const lines: string[] = [];
+  let current = "";
+  let currentW = 0;
+  for (const ch of text) {
+    const cw = displayWidth(ch);
+    if (cw > 0 && currentW + cw > width && current.length > 0) {
+      lines.push(current);
+      current = ch;
+      currentW = cw;
+    } else {
+      current += ch;
+      currentW += cw;
+    }
+  }
+  lines.push(current);
+  return lines;
+}