@pi-archimedes/diff 1.6.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/diff",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "type": "module",
   "keywords": [
     "pi-package"

package/src/ansi/manip.test.ts

@@ -0,0 +1,213 @@
+import { describe, it, expect } from "vitest";
+import { strip, tabs, fit, ansiState, isLowContrastShikiFg, normalizeShikiContrast, lnum, shortPath, summarize } from "./manip.js";
+import * as C from "./codes.js";
+
+// ── strip ───────────────────────────────────────────────────────────────────
+
+describe("strip", () => {
+  it("removes SGR sequences", () => {
+    expect(strip("\x1b[31mred\x1b[0m")).toBe("red");
+    expect(strip("\x1b[1m\x1b[31mhi\x1b[0m")).toBe("hi");
+  });
+
+  it("empty string stays empty", () => {
+    expect(strip("")).toBe("");
+  });
+});
+
+// ── tabs ────────────────────────────────────────────────────────────────────
+
+describe("tabs", () => {
+  it("replaces \\t with 2 spaces", () => {
+    expect(tabs("a\tb")).toBe("a  b");
+    expect(tabs("\t")).toBe("  ");
+    expect(tabs("no\ttabs\there")).toBe("no  tabs  here");
+  });
+});
+
+// ── fit ─────────────────────────────────────────────────────────────────────
+
+describe("fit", () => {
+  it("truncates to width (ASCII)", () => {
+    const result = fit("hello world", 8);
+    expect(result).toContain("hello");
+    // Should end with truncation indicator
+    expect(result).toContain("›");
+  });
+
+  it("truncates to width (wide chars — never splits grapheme)", () => {
+    // "中日" is 4 columns. fit to 3 should drop "日" (2 cols) since it
+    // would overflow, keeping only "中" (2 cols)
+    const result = fit("中日", 3);
+    expect(result).toContain("中");
+    // "日" should not appear since it's 2 cols and would overflow budget of 2 (3-1)
+    expect(result).not.toContain("日");
+  });
+
+  it("pads short strings", () => {
+    const result = fit("hi", 5);
+    expect(result).toBe("hi   ");
+  });
+
+  it("width 0 returns empty", () => {
+    expect(fit("hello", 0)).toBe("");
+  });
+
+  it("wide grapheme wider than budget is dropped", () => {
+    // Budget of 1 — wide char "中" (2 cols) can't fit, should be dropped
+    const result = fit("中", 1);
+    expect(result).not.toContain("中");
+  });
+});
+
+// ── ansiState ───────────────────────────────────────────────────────────────
+
+describe("ansiState", () => {
+  it("extracts last fg code (truecolor)", () => {
+    const state = ansiState("\x1b[38;2;255;0;0mhello");
+    expect(state).toContain("\x1b[38;2;255;0;0m");
+  });
+
+  it("extracts last bg code (truecolor)", () => {
+    const state = ansiState("\x1b[48;2;0;255;0mhello");
+    expect(state).toContain("\x1b[48;2;0;255;0m");
+  });
+
+  it("returns bg + fg (background first!)", () => {
+    const state = ansiState("\x1b[38;2;255;0;0m\x1b[48;2;0;0;255mtext");
+    // bg should come before fg in the return value
+    const bgIdx = state.indexOf("\x1b[48;2;0;0;255m");
+    const fgIdx = state.indexOf("\x1b[38;2;255;0;0m");
+    expect(bgIdx).toBeLessThan(fgIdx);
+  });
+
+  it("\\x1b[0m resets both", () => {
+    const state = ansiState("\x1b[38;2;255;0;0m\x1b[0m");
+    expect(state).toBe("");
+  });
+
+  it("truecolor fg/bg", () => {
+    const state = ansiState("\x1b[38;2;255;0;0m\x1b[48;2;0;0;255mtext");
+    expect(state).toContain("\x1b[38;2;255;0;0m");
+    expect(state).toContain("\x1b[48;2;0;0;255m");
+  });
+
+  it("\\x1b[39m resets only fg", () => {
+    const state = ansiState("\x1b[38;2;255;0;0m\x1b[48;2;0;0;255m\x1b[39mtext");
+    expect(state).toContain("\x1b[48;2;0;0;255m");
+    expect(state).not.toContain("\x1b[38;2;255;0;0m");
+  });
+
+  it("plain ANSI codes (31, 42) are not tracked — Shiki uses truecolor", () => {
+    // ansiState only tracks 38;..., 48;..., 39, 0 — plain codes like 31/42 pass through
+    const state = ansiState("\x1b[31m\x1b[42mhello");
+    expect(state).toBe("");
+  });
+});
+
+// ── isLowContrastShikiFg ────────────────────────────────────────────────────
+
+describe("isLowContrastShikiFg", () => {
+  it('"30" = true (dark black)', () => {
+    expect(isLowContrastShikiFg("30")).toBe(true);
+  });
+
+  it('"90" = true (dark gray)', () => {
+    expect(isLowContrastShikiFg("90")).toBe(true);
+  });
+
+  it('"38;5;0" = true (256 palette black)', () => {
+    expect(isLowContrastShikiFg("38;5;0")).toBe(true);
+  });
+
+  it('"38;5;8" = true (256 palette dark gray)', () => {
+    expect(isLowContrastShikiFg("38;5;8")).toBe(true);
+  });
+
+  it('"38;2;0;0;0" = true (truecolor black)', () => {
+    expect(isLowContrastShikiFg("38;2;0;0;0")).toBe(true);
+  });
+
+  it('"38;2;255;255;255" = false (truecolor white)', () => {
+    expect(isLowContrastShikiFg("38;2;255;255;255")).toBe(false);
+  });
+
+  it('"0" = false (reset, not a fg code)', () => {
+    expect(isLowContrastShikiFg("0")).toBe(false);
+  });
+
+  it('"38;5;5" = false (256 palette not-dark)', () => {
+    expect(isLowContrastShikiFg("38;5;5")).toBe(false);
+  });
+
+  it('"48;2;0;0;0" = false (background not foreground)', () => {
+    expect(isLowContrastShikiFg("48;2;0;0;0")).toBe(false);
+  });
+});
+
+// ── normalizeShikiContrast ──────────────────────────────────────────────────
+
+describe("normalizeShikiContrast", () => {
+  it("replaces low-contrast codes", () => {
+    // \x1b[30m is dark black — should be replaced
+    const result = normalizeShikiContrast("\x1b[30mtext\x1b[0m");
+    expect(result).toContain(C.FG_SAFE_MUTED);
+    expect(result).not.toContain("\x1b[30m");
+  });
+
+  it("leaves high-contrast alone", () => {
+    // \x1b[37m is white — should pass through
+    const result = normalizeShikiContrast("\x1b[37mtext\x1b[0m");
+    expect(result).toContain("\x1b[37m");
+  });
+});
+
+// ── lnum ────────────────────────────────────────────────────────────────────
+
+describe("lnum", () => {
+  it("formats number right-padded", () => {
+    const result = lnum(42, 5);
+    expect(result).toContain("42");
+    // Should have spaces before the number
+    const stripped = result.replace(C.RST, "").replace(C.FG_LNUM, "");
+    expect(stripped).toBe("   42");
+  });
+
+  it("null produces spaces", () => {
+    const result = lnum(null, 5);
+    expect(result).toBe("     ");
+  });
+});
+
+// ── shortPath ───────────────────────────────────────────────────────────────
+
+describe("shortPath", () => {
+  it("relative to cwd returns relative", () => {
+    const result = shortPath("/home/user/project", "/home/user", "/home/user/project/src/file.ts");
+    expect(result).toBe("src/file.ts");
+  });
+
+  it("outside cwd with home returns ~", () => {
+    const result = shortPath("/home/user/project", "/home/user", "/home/user/other/file.ts");
+    expect(result).toBe("~/other/file.ts");
+  });
+
+  it("empty returns empty", () => {
+    expect(shortPath("/cwd", "/home", "")).toBe("");
+  });
+});
+
+// ── summarize ───────────────────────────────────────────────────────────────
+
+describe("summarize", () => {
+  it("+N -M format", () => {
+    const result = summarize(3, 2);
+    expect(result).toContain("+3");
+    expect(result).toContain("-2");
+  });
+
+  it("zero changes returns 'no changes'", () => {
+    const result = summarize(0, 0);
+    expect(result).toContain("no changes");
+  });
+});

package/src/ansi/width.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from "vitest";
+import { graphemeWidth, tokenize, visibleWidth } from "./width.js";
+
+// ── graphemeWidth ───────────────────────────────────────────────────────────
+
+describe("graphemeWidth", () => {
+  it("ASCII letter = 1", () => {
+    expect(graphemeWidth("a")).toBe(1);
+    expect(graphemeWidth("Z")).toBe(1);
+  });
+
+  it("CJK character = 2", () => {
+    expect(graphemeWidth("中")).toBe(2);
+    expect(graphemeWidth("日")).toBe(2);
+    expect(graphemeWidth("韩")).toBe(2);
+  });
+
+  it("emoji = 2", () => {
+    expect(graphemeWidth("✅")).toBe(2);
+    expect(graphemeWidth("🔥")).toBe(2);
+    expect(graphemeWidth("😀")).toBe(2);
+  });
+
+  it("zero-width combining marks = 0", () => {
+    // Combining acute accent (U+0301) — zero width on its own
+    expect(graphemeWidth("\u0301")).toBe(0);
+    // Combining tilde (U+0303)
+    expect(graphemeWidth("\u0303")).toBe(0);
+  });
+
+  it("tab = 2", () => {
+    expect(graphemeWidth("\t")).toBe(2);
+  });
+});
+
+// ── tokenize ────────────────────────────────────────────────────────────────
+
+describe("tokenize", () => {
+  it("plain text produces single tokens", () => {
+    const tokens = tokenize("ab");
+    expect(tokens).toHaveLength(2);
+    expect(tokens[0]).toEqual({ ansi: "", text: "a", width: 1 });
+    expect(tokens[1]).toEqual({ ansi: "", text: "b", width: 1 });
+  });
+
+  it("SGR sequence produces ansi+text pairs", () => {
+    // \x1b[31m is red fg, followed by "a"
+    const tokens = tokenize("\x1b[31ma");
+    expect(tokens).toHaveLength(1);
+    expect(tokens[0]).toEqual({ ansi: "\x1b[31m", text: "a", width: 1 });
+  });
+
+  it("bare ESC without m terminator handled gracefully", () => {
+    // ESC (0x1b) with no 'm' after it — should not hang
+    const tokens = tokenize("\x1ba");
+    // The bare ESC produces a zero-width token, then "a" is a normal token
+    expect(tokens.length).toBeGreaterThanOrEqual(2);
+    // Last token should be the "a"
+    expect(tokens[tokens.length - 1]!.text).toBe("a");
+  });
+
+  it("mixed ANSI + text", () => {
+    const tokens = tokenize("\x1b[31mred\x1b[0mplain");
+    // "red" under \x1b[31m, then "plain" after reset
+    const redToken = tokens.find((t) => t.text === "r");
+    expect(redToken?.ansi).toBe("\x1b[31m");
+
+    const plainToken = tokens.find((t) => t.text === "p");
+    expect(plainToken?.ansi).toBe("\x1b[0m");
+  });
+});
+
+// ── visibleWidth ────────────────────────────────────────────────────────────
+
+describe("visibleWidth", () => {
+  it("plain ASCII length matches", () => {
+    expect(visibleWidth("hello")).toBe(5);
+    expect(visibleWidth("abc")).toBe(3);
+  });
+
+  it("wide chars counted correctly", () => {
+    expect(visibleWidth("中")).toBe(2);
+    expect(visibleWidth("中日")).toBe(4);
+    expect(visibleWidth("a中b")).toBe(4); // 1 + 2 + 1
+  });
+
+  it("ANSI escapes don't add width", () => {
+    expect(visibleWidth("\x1b[31mhello\x1b[0m")).toBe(5);
+    expect(visibleWidth("\x1b[1m\x1b[31mhi\x1b[0m")).toBe(2);
+  });
+
+  it("empty string = 0", () => {
+    expect(visibleWidth("")).toBe(0);
+  });
+});

package/src/word-diff.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from "vitest";
+import { wordDiffAnalysis, injectBg, plainWordDiff } from "./word-diff.js";
+import * as Ansi from "./ansi/index.js";
+import type { DiffBg } from "./ansi/index.js";
+
+// ── wordDiffAnalysis ────────────────────────────────────────────────────────
+
+describe("wordDiffAnalysis", () => {
+  it("identical strings → similarity 1, empty ranges", () => {
+    const result = wordDiffAnalysis("hello world", "hello world");
+    expect(result.similarity).toBe(1);
+    expect(result.oldRanges).toEqual([]);
+    expect(result.newRanges).toEqual([]);
+  });
+
+  it("completely different → similarity 0, full ranges", () => {
+    const result = wordDiffAnalysis("abc", "xyz");
+    expect(result.similarity).toBe(0);
+    expect(result.oldRanges).toEqual([[0, 3]]);
+    expect(result.newRanges).toEqual([[0, 3]]);
+  });
+
+  it("partial overlap → correct similarity and ranges", () => {
+    const result = wordDiffAnalysis("hello world", "hello earth");
+    expect(result.similarity).toBeGreaterThan(0);
+    expect(result.similarity).toBeLessThan(1);
+    // "world" changed to "earth" — both 5 chars, same position in new string
+    expect(result.oldRanges.length).toBeGreaterThan(0);
+    expect(result.newRanges.length).toBeGreaterThan(0);
+  });
+
+  it("one empty string", () => {
+    const result = wordDiffAnalysis("hello", "");
+    expect(result.similarity).toBe(0);
+    expect(result.oldRanges).toEqual([[0, 5]]);
+    expect(result.newRanges).toEqual([]);
+  });
+
+  it("both empty → similarity 1", () => {
+    const result = wordDiffAnalysis("", "");
+    expect(result.similarity).toBe(1);
+    expect(result.oldRanges).toEqual([]);
+    expect(result.newRanges).toEqual([]);
+  });
+});
+
+// ── injectBg ────────────────────────────────────────────────────────────────
+
+describe("injectBg", () => {
+  const baseBg = "\x1b[48;2;10;20;30m";
+  const hlBg = "\x1b[48;2;200;50;50m";
+
+  it("no ranges returns baseBg + ansiLine + Ansi.RST (trailing reset!)", () => {
+    const result = injectBg("hello", [], baseBg, hlBg);
+    expect(result).toBe(baseBg + "hello" + Ansi.RST);
+  });
+
+  it("single range with concrete example", () => {
+    // "hello" with highlight on [2,4] → "he" + highlight "ll" + "o"
+    const result = injectBg("hello", [[2, 4]], baseBg, hlBg);
+    expect(result).toBe(
+      baseBg + "he" + hlBg + "ll" + baseBg + "o" + Ansi.RST
+    );
+  });
+
+  it("overlapping ranges merged", () => {
+    // [[1, 4], [3, 6]] should merge to [[1, 6]]
+    const result = injectBg("abcdef", [[1, 4], [3, 6]], baseBg, hlBg);
+    // "a" is base, "bcdef" is highlighted
+    expect(result).toBe(
+      baseBg + "a" + hlBg + "bcdef" + Ansi.RST
+    );
+  });
+
+  it("\\x1b[0m triggers bg re-injection", () => {
+    // When a reset appears mid-string, bg should be re-injected after it
+    const ansiLine = "he\x1b[0mllo";
+    const result = injectBg(ansiLine, [[2, 4]], baseBg, hlBg);
+    // After \x1b[0m, the bg should be re-injected
+    expect(result).toContain(baseBg);
+    // The reset should still be present
+    expect(result).toContain("\x1b[0m");
+  });
+});
+
+// ── plainWordDiff ───────────────────────────────────────────────────────────
+
+describe("plainWordDiff", () => {
+  const dbg: DiffBg = Ansi.DEFAULT_DIFF_BG;
+
+  it("removed text gets del bg", () => {
+    const result = plainWordDiff("hello world", "hello", dbg);
+    expect(result.old).toContain(dbg.bgDelW);
+    expect(result.old).toContain("world");
+    expect(result.new).toBe("hello");
+  });
+
+  it("added text gets add bg", () => {
+    const result = plainWordDiff("hello", "hello world", dbg);
+    expect(result.new).toContain(dbg.bgAddW);
+    expect(result.new).toContain("world");
+    // diffWords treats the space as unchanged, so old includes trailing space
+    expect(result.old).toBe("hello ");
+  });
+
+  it("unchanged passed through", () => {
+    const result = plainWordDiff("hello", "hello", dbg);
+    expect(result.old).toBe("hello");
+    expect(result.new).toBe("hello");
+  });
+});