@aaroncql/pim-agent 0.0.1

package/src/shared/DiffLines.ts

@@ -0,0 +1,307 @@
+import * as Diff from "diff";
+
+export type ToolDiffLineKind = "context" | "added" | "removed";
+
+export type IntraLineRange = {
+  readonly start: number;
+  readonly end: number;
+};
+
+export type ToolDiffLine = {
+  readonly kind: ToolDiffLineKind;
+  readonly oldLine?: number;
+  readonly newLine?: number;
+  readonly text: string;
+  readonly emphasis?: readonly IntraLineRange[];
+};
+
+export type ToolDiffHunk = {
+  readonly oldStart: number;
+  readonly oldLines: number;
+  readonly newStart: number;
+  readonly newLines: number;
+  readonly lines: readonly ToolDiffLine[];
+};
+
+export type ToolDiff = {
+  readonly path: string;
+  readonly hunks: readonly ToolDiffHunk[];
+};
+
+// Logical lines (no trailing empty token) plus an explicit EOF-newline flag.
+// Don't fold the flag back into the array: a raw `split("\n")` would make
+// `joinComparable` emit a phantom blank line on every append.
+export type ToolDiffSide = {
+  readonly lines: readonly string[];
+  readonly hasTrailingNewline: boolean;
+};
+
+export class DiffLines {
+  public static buildToolDiff(
+    path: string,
+    oldSide: ToolDiffSide,
+    newSide: ToolDiffSide,
+    contextSize: number
+  ): ToolDiff | undefined {
+    if (contextSize < 0 || !Number.isFinite(contextSize)) {
+      throw new Error(
+        `contextSize must be a non-negative finite number, got ${contextSize}.`
+      );
+    }
+
+    const lines = DiffLines.build(oldSide.lines, newSide.lines);
+
+    if (!lines.some((line) => line.kind !== "context")) {
+      return undefined;
+    }
+
+    const emphasized = DiffLines.attachEmphasis(lines);
+
+    return {
+      path,
+      hunks: DiffLines.buildHunks(emphasized, contextSize),
+    };
+  }
+
+  public static fromText(text: string): ToolDiffSide {
+    if (text.length === 0) {
+      return { lines: [], hasTrailingNewline: false };
+    }
+
+    const hasTrailingNewline = text.endsWith("\n");
+    const parts = text.split("\n");
+
+    if (hasTrailingNewline) {
+      parts.pop();
+    }
+
+    return { lines: parts, hasTrailingNewline };
+  }
+
+  private static attachEmphasis(
+    lines: readonly ToolDiffLine[]
+  ): readonly ToolDiffLine[] {
+    const result: ToolDiffLine[] = [...lines];
+    let i = 0;
+
+    while (i < result.length) {
+      if (result[i]?.kind !== "removed") {
+        i += 1;
+        continue;
+      }
+
+      let removedEnd = i;
+      while (
+        removedEnd < result.length &&
+        result[removedEnd]?.kind === "removed"
+      ) {
+        removedEnd += 1;
+      }
+
+      let addedEnd = removedEnd;
+      while (addedEnd < result.length && result[addedEnd]?.kind === "added") {
+        addedEnd += 1;
+      }
+
+      const removedCount = removedEnd - i;
+      const addedCount = addedEnd - removedEnd;
+
+      if (removedCount > 0 && removedCount === addedCount) {
+        for (let k = 0; k < removedCount; k += 1) {
+          const removed = result[i + k];
+          const added = result[removedEnd + k];
+
+          if (removed === undefined || added === undefined) {
+            continue;
+          }
+
+          const ranges = DiffLines.computeIntraLineRanges(
+            removed.text,
+            added.text
+          );
+
+          if (ranges === undefined) {
+            continue;
+          }
+
+          result[i + k] = { ...removed, emphasis: ranges.removed };
+          result[removedEnd + k] = { ...added, emphasis: ranges.added };
+        }
+      }
+
+      i = addedEnd > i ? addedEnd : i + 1;
+    }
+
+    return result;
+  }
+
+  private static computeIntraLineRanges(
+    oldText: string,
+    newText: string
+  ):
+    | {
+        readonly removed: readonly IntraLineRange[];
+        readonly added: readonly IntraLineRange[];
+      }
+    | undefined {
+    const parts = Diff.diffWords(oldText, newText);
+    const removedRanges: IntraLineRange[] = [];
+    const addedRanges: IntraLineRange[] = [];
+    let oldPos = 0;
+    let newPos = 0;
+    let sharedLen = 0;
+    let firstRemoved = true;
+    let firstAdded = true;
+
+    for (const part of parts) {
+      const len = part.value.length;
+
+      if (part.added === true) {
+        const leading = firstAdded ? DiffLines.leadingWsLen(part.value) : 0;
+        firstAdded = false;
+        if (len - leading > 0) {
+          addedRanges.push({ start: newPos + leading, end: newPos + len });
+        }
+        newPos += len;
+        continue;
+      }
+
+      if (part.removed === true) {
+        const leading = firstRemoved ? DiffLines.leadingWsLen(part.value) : 0;
+        firstRemoved = false;
+        if (len - leading > 0) {
+          removedRanges.push({ start: oldPos + leading, end: oldPos + len });
+        }
+        oldPos += len;
+        continue;
+      }
+
+      sharedLen += len;
+      oldPos += len;
+      newPos += len;
+    }
+
+    if (sharedLen === 0) {
+      return undefined;
+    }
+
+    return { removed: removedRanges, added: addedRanges };
+  }
+
+  private static build(
+    oldLines: readonly string[],
+    newLines: readonly string[]
+  ): readonly ToolDiffLine[] {
+    const parts = Diff.diffLines(
+      DiffLines.joinComparable(oldLines),
+      DiffLines.joinComparable(newLines)
+    );
+    const lines: ToolDiffLine[] = [];
+    let oldLine = 1;
+    let newLine = 1;
+
+    for (const part of parts) {
+      const values = DiffLines.partLines(part.value);
+
+      for (const text of values) {
+        if (part.added === true) {
+          lines.push({ kind: "added", newLine, text });
+          newLine += 1;
+          continue;
+        }
+
+        if (part.removed === true) {
+          lines.push({ kind: "removed", oldLine, text });
+          oldLine += 1;
+          continue;
+        }
+
+        lines.push({ kind: "context", oldLine, newLine, text });
+        oldLine += 1;
+        newLine += 1;
+      }
+    }
+
+    return lines;
+  }
+
+  private static buildHunks(
+    lines: readonly ToolDiffLine[],
+    contextSize: number
+  ): readonly ToolDiffHunk[] {
+    const changeIndexes = lines
+      .map((line, index) => (line.kind === "context" ? -1 : index))
+      .filter((index) => index >= 0);
+    const hunks: ToolDiffHunk[] = [];
+    let firstChange = changeIndexes[0];
+    let lastChange = changeIndexes[0];
+
+    if (firstChange === undefined || lastChange === undefined) {
+      return hunks;
+    }
+
+    const pushHunk = (startChange: number, endChange: number): void => {
+      const hunkLines = lines.slice(
+        Math.max(0, startChange - contextSize),
+        Math.min(lines.length, endChange + contextSize + 1)
+      );
+      const oldNumbers = hunkLines.flatMap((line) =>
+        line.oldLine === undefined ? [] : [line.oldLine]
+      );
+      const newNumbers = hunkLines.flatMap((line) =>
+        line.newLine === undefined ? [] : [line.newLine]
+      );
+      const oldStart =
+        oldNumbers.length === 0
+          ? Math.max(0, (newNumbers[0] ?? 1) - 1)
+          : Math.min(...oldNumbers);
+      const newStart =
+        newNumbers.length === 0
+          ? Math.max(0, (oldNumbers[0] ?? 1) - 1)
+          : Math.min(...newNumbers);
+
+      hunks.push({
+        oldStart,
+        oldLines:
+          oldNumbers.length === 0 ? 0 : Math.max(...oldNumbers) - oldStart + 1,
+        newStart,
+        newLines:
+          newNumbers.length === 0 ? 0 : Math.max(...newNumbers) - newStart + 1,
+        lines: hunkLines,
+      });
+    };
+
+    for (const changeIndex of changeIndexes.slice(1)) {
+      if (changeIndex - lastChange <= contextSize * 2 + 1) {
+        lastChange = changeIndex;
+        continue;
+      }
+
+      pushHunk(firstChange, lastChange);
+      firstChange = changeIndex;
+      lastChange = changeIndex;
+    }
+
+    pushHunk(firstChange, lastChange);
+
+    return hunks;
+  }
+
+  private static leadingWsLen(value: string): number {
+    return value.match(/^\s*/)?.[0].length ?? 0;
+  }
+
+  private static joinComparable(lines: readonly string[]): string {
+    return lines.length === 0 ? "" : `${lines.join("\n")}\n`;
+  }
+
+  private static partLines(value: string): readonly string[] {
+    const lines = value.split("\n");
+
+    if (lines.at(-1) === "") {
+      lines.pop();
+    }
+
+    return lines;
+  }
+}

package/src/shared/DiffRenderer.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, test } from "bun:test";
+import { DiffLines, type ToolDiffHunk } from "./DiffLines";
+import { DiffRenderer, type DiffHighlighter } from "./DiffRenderer";
+
+const tagHighlighter: DiffHighlighter = (block) =>
+  block.split("\n").map((line) => `<H>${line}</H>`);
+
+const recordingHighlighter = (calls: string[][]): DiffHighlighter => {
+  return (block) => {
+    const lines = block.split("\n");
+    calls.push(lines);
+    return lines.map((line) => `<H>${line}</H>`);
+  };
+};
+
+const firstHunk = (
+  oldText: readonly string[],
+  newText: readonly string[]
+): ToolDiffHunk => {
+  const diff = DiffLines.buildToolDiff(
+    "foo.ts",
+    { lines: oldText, hasTrailingNewline: true },
+    { lines: newText, hasTrailingNewline: true },
+    1
+  );
+
+  if (diff === undefined || diff.hunks[0] === undefined) {
+    throw new Error("expected at least one hunk");
+  }
+
+  return diff.hunks[0];
+};
+
+describe("DiffRenderer.highlightHunkLines", () => {
+  test("highlights added lines using the new-side block", () => {
+    const hunk = firstHunk(["a", "b", "c"], ["a", "b", "c", "d"]);
+    const result = DiffRenderer.highlightHunkLines(hunk, tagHighlighter);
+
+    expect(result).toEqual(hunk.lines.map((line) => `<H>${line.text}</H>`));
+  });
+
+  test("highlights removed lines using the old-side block", () => {
+    const hunk = firstHunk(["a", "b", "c"], ["a", "c"]);
+    const result = DiffRenderer.highlightHunkLines(hunk, tagHighlighter);
+
+    expect(result).toEqual(hunk.lines.map((line) => `<H>${line.text}</H>`));
+  });
+
+  test("passes old and new versions as multi-line blocks (not per line)", () => {
+    const hunk = firstHunk(
+      ["line1", "old-mid", "line3"],
+      ["line1", "new-mid", "line3"]
+    );
+    const calls: string[][] = [];
+    DiffRenderer.highlightHunkLines(hunk, recordingHighlighter(calls));
+
+    expect(calls).toHaveLength(2);
+    expect(calls).toContainEqual(["line1", "old-mid", "line3"]);
+    expect(calls).toContainEqual(["line1", "new-mid", "line3"]);
+  });
+
+  test("maps each diff line to the correct highlighted entry", () => {
+    const hunk = firstHunk(
+      ["keep", "drop1", "drop2", "tail"],
+      ["keep", "add1", "add2", "tail"]
+    );
+    const result = DiffRenderer.highlightHunkLines(hunk, tagHighlighter);
+
+    for (let i = 0; i < hunk.lines.length; i += 1) {
+      expect(result[i]).toBe(`<H>${hunk.lines[i]?.text}</H>`);
+    }
+  });
+
+  test("falls back to raw text when highlighter returns shorter array", () => {
+    const hunk = firstHunk(["a"], ["a", "b"]);
+    const truncating: DiffHighlighter = () => [];
+    const result = DiffRenderer.highlightHunkLines(hunk, truncating);
+
+    expect(result).toEqual(hunk.lines.map((line) => line.text));
+  });
+
+  test("skips highlighter calls when one side is empty", () => {
+    const hunk = firstHunk(["a", "b"], ["a", "b", "c", "d"]);
+    const calls: string[][] = [];
+    DiffRenderer.highlightHunkLines(hunk, recordingHighlighter(calls));
+
+    for (const call of calls) {
+      expect(call.length).toBeGreaterThan(0);
+    }
+  });
+});
+
+describe("DiffRenderer.render", () => {
+  const stubTheme = {
+    name: "pim-dark",
+    fg: (_color: string, text: string) => text,
+  } as unknown as Parameters<typeof DiffRenderer.render>[0]["theme"];
+
+  test("returns empty string for empty diff", () => {
+    const out = DiffRenderer.render({
+      toolDiff: { path: "foo.ts", hunks: [] },
+      theme: stubTheme,
+    });
+    expect(out).toBe("");
+  });
+
+  test("includes content for each diff line", () => {
+    const diff = DiffLines.buildToolDiff(
+      "foo.ts",
+      { lines: ["alpha", "beta", "gamma"], hasTrailingNewline: true },
+      { lines: ["alpha", "BETA", "gamma"], hasTrailingNewline: true },
+      1
+    );
+
+    if (diff === undefined) {
+      throw new Error("expected diff");
+    }
+
+    const out = DiffRenderer.render({ toolDiff: diff, theme: stubTheme });
+
+    expect(out).toContain("alpha");
+    expect(out).toContain("beta");
+    expect(out).toContain("BETA");
+    expect(out).toContain("gamma");
+  });
+
+  test("emits emphasis bg for paired changed lines", () => {
+    const diff = DiffLines.buildToolDiff(
+      "foo.ts",
+      { lines: ["const x = 1;"], hasTrailingNewline: true },
+      { lines: ["const y = 2;"], hasTrailingNewline: true },
+      1
+    );
+
+    if (diff === undefined) {
+      throw new Error("expected diff");
+    }
+
+    const out = DiffRenderer.render({ toolDiff: diff, theme: stubTheme });
+
+    expect(out).toContain("\x1b[48;2;26;81;47m");
+    expect(out).toContain("\x1b[48;2;100;35;35m");
+  });
+
+  test("does not render any EOF newline marker (EOF state is surfaced by callers, not the renderer)", () => {
+    const diff = DiffLines.buildToolDiff(
+      "foo.ts",
+      { lines: ["alpha"], hasTrailingNewline: false },
+      { lines: ["beta"], hasTrailingNewline: true },
+      1
+    );
+
+    if (diff === undefined) {
+      throw new Error("expected diff");
+    }
+
+    const out = DiffRenderer.render({ toolDiff: diff, theme: stubTheme });
+    expect(out).not.toContain("No newline at end of file");
+    expect(out).not.toContain("Newline added");
+  });
+});
+
+describe("DiffRenderer.applyEmphasis", () => {
+  const lineBg = "\x1b[48;2;0;0;0m";
+  const emphBg = "\x1b[48;2;255;255;255m";
+
+  test("returns text unchanged when no ranges", () => {
+    expect(DiffRenderer.applyEmphasis("hello", [], lineBg, emphBg)).toBe(
+      "hello"
+    );
+  });
+
+  test("wraps an emphasized range with emph then line bg", () => {
+    const out = DiffRenderer.applyEmphasis(
+      "hello world",
+      [{ start: 6, end: 11 }],
+      lineBg,
+      emphBg
+    );
+    expect(out).toBe(`hello ${emphBg}world${lineBg}`);
+  });
+
+  test("counts visible chars only, ignoring ANSI escape sequences", () => {
+    const colored = `\x1b[31mhello\x1b[39m world`;
+    const out = DiffRenderer.applyEmphasis(
+      colored,
+      [{ start: 6, end: 11 }],
+      lineBg,
+      emphBg
+    );
+    expect(out).toBe(`\x1b[31mhello\x1b[39m ${emphBg}world${lineBg}`);
+  });
+
+  test("supports multiple non-overlapping ranges", () => {
+    const out = DiffRenderer.applyEmphasis(
+      "abcdef",
+      [
+        { start: 0, end: 2 },
+        { start: 4, end: 6 },
+      ],
+      lineBg,
+      emphBg
+    );
+    expect(out).toBe(`${emphBg}ab${lineBg}cd${emphBg}ef${lineBg}`);
+  });
+});