@selesai/code 0.10.2 → 0.12.0

package/dist/extensions/pi-tool-display/tests/tool-ui-utils.test.ts

@@ -0,0 +1,413 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import {
+  countWriteContentLines,
+  getWriteContentSizeBytes,
+  shouldRenderWriteCallSummary,
+} from "../src/write-display-utils.ts";
+import {
+  extractUserMessageMarkdownState,
+} from "../src/user-message-box-markdown.ts";
+import {
+  createUserMessageMarkdownLineRenderer,
+  patchNativeUserMessagePrototype,
+  shouldBypassUserMessageMarkdownRebuild,
+} from "../src/user-message-box-renderer.ts";
+import {
+  patchUserMessageRenderPrototype,
+  type PatchableUserMessagePrototype,
+} from "../src/user-message-box-patch.ts";
+import {
+  addUserMessageVerticalPadding,
+  applyUserMessageBackground,
+  normalizeUserMessageContentLine,
+  normalizeUserMessageContentLines,
+} from "../src/user-message-box-utils.ts";
+import {
+  buildCollapsedDiffHintText,
+  clampRenderedLineToWidth,
+} from "../src/line-width-safety.ts";
+import { buildPendingEditPreviewData } from "../src/pending-diff-preview.ts";
+
+const codePointWidthOps = {
+  measure: (text: string): number => [...text].length,
+  truncate: (text: string, maxWidth: number): string =>
+    [...text].slice(0, Math.max(0, maxWidth)).join(""),
+};
+
+
+test("pending edit preview matches LF edit input against CRLF files", () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "pi-tool-display-preview-"));
+
+  try {
+    const filePath = join(baseDir, "sample.txt");
+    writeFileSync(filePath, "alpha\r\nbeta\r\ngamma\r\n", "utf8");
+
+    const preview = buildPendingEditPreviewData(
+      {
+        path: "sample.txt",
+        edits: [
+          {
+            oldText: "alpha\nbeta",
+            newText: "alpha\nupdated",
+          },
+        ],
+      },
+      baseDir,
+    );
+
+    assert.equal(preview?.notice, undefined);
+    assert.equal(preview?.nextContent, "alpha\r\nupdated\r\ngamma\r\n");
+    assert.equal(preview?.previousContent, "alpha\r\nbeta\r\ngamma\r\n");
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+test("pending edit preview reports a concise notice for true edit mismatches", () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "pi-tool-display-preview-miss-"));
+
+  try {
+    writeFileSync(join(baseDir, "sample.txt"), "alpha\nbeta\n", "utf8");
+
+    const preview = buildPendingEditPreviewData(
+      {
+        path: "sample.txt",
+        edits: [
+          {
+            oldText: "missing",
+            newText: "updated",
+          },
+        ],
+      },
+      baseDir,
+    );
+
+    assert.equal(preview?.nextContent, undefined);
+    assert.equal(preview?.notice, "Preview not shown: edit #1 did not match the current file contents.");
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+test("write call summary moves metrics onto the first line when the result header omits them", () => {
+  assert.equal(
+    shouldRenderWriteCallSummary({
+      hasContent: true,
+      hasDetailedResultHeader: false,
+    }),
+    true,
+  );
+  assert.equal(
+    shouldRenderWriteCallSummary({
+      hasContent: true,
+      hasDetailedResultHeader: true,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldRenderWriteCallSummary({
+      hasContent: false,
+      hasDetailedResultHeader: false,
+    }),
+    false,
+  );
+});
+
+test("write content line counting ignores trailing newlines", () => {
+  assert.equal(countWriteContentLines("alpha\nbeta\n"), 2);
+  assert.equal(countWriteContentLines("alpha\r\nbeta"), 2);
+  assert.equal(countWriteContentLines(""), 0);
+});
+
+test("write content size uses utf-8 bytes", () => {
+  assert.equal(getWriteContentSizeBytes("hello"), 5);
+  assert.equal(getWriteContentSizeBytes("é"), 2);
+});
+
+test("user message patch reapplies on reload when an older patch version is already present", () => {
+  const originalRender = (width: number): string[] => [`original:${width}`];
+  const prototype: PatchableUserMessagePrototype = {
+    render: (width: number): string[] => [`stale:${width}`],
+    __piUserMessageOriginalRender: originalRender,
+    __piUserMessageNativePatched: true,
+    __piUserMessagePatchVersion: 1,
+  };
+
+  patchUserMessageRenderPrototype(prototype, 5, (baseRender) => {
+    return function patched(width: number): string[] {
+      return [`patched:${baseRender.call(this, width).join("|")}`];
+    };
+  });
+
+  assert.deepEqual(prototype.render(14), ["patched:original:14"]);
+  assert.equal(prototype.__piUserMessagePatchVersion, 5);
+  assert.equal(prototype.__piUserMessageNativePatched, true);
+});
+
+test("user message markdown extraction removes nested background styling", () => {
+  const theme = { heading: () => "" };
+  const color = (text: string): string => text;
+  const extracted = extractUserMessageMarkdownState({
+    children: [
+      { lines: 1 },
+      {
+        text: "Hello **WezTerm**",
+        theme,
+        defaultTextStyle: {
+          color,
+          bgColor: (text: string): string => text,
+          bold: true,
+        },
+      },
+    ],
+  });
+
+  assert.equal(extracted?.text, "Hello **WezTerm**");
+  assert.equal(extracted?.theme, theme);
+  assert.equal(extracted?.defaultTextStyle?.color, color);
+  assert.equal(extracted?.defaultTextStyle?.bold, true);
+  assert.equal("bgColor" in (extracted?.defaultTextStyle ?? {}), false);
+});
+
+test("user message markdown extraction finds markdown nested inside the native box", () => {
+  const theme = { heading: () => "" };
+  const color = (text: string): string => text;
+  const extracted = extractUserMessageMarkdownState({
+    children: [
+      {
+        children: [
+          {
+            text: "Nested **markdown**",
+            theme,
+            defaultTextStyle: {
+              color,
+              bgColor: (text: string): string => text,
+            },
+          },
+        ],
+      },
+    ],
+  });
+
+  assert.equal(extracted?.text, "Nested **markdown**");
+  assert.equal(extracted?.theme, theme);
+  assert.equal(extracted?.defaultTextStyle?.color, color);
+  assert.equal("bgColor" in (extracted?.defaultTextStyle ?? {}), false);
+});
+
+test("user message markdown renderer reuses cached markdown renders for identical state", () => {
+  let rendererCreationCount = 0;
+  let renderCallCount = 0;
+  const renderMarkdown = createUserMessageMarkdownLineRenderer((state) => {
+    rendererCreationCount++;
+    return {
+      render(width: number): string[] {
+        renderCallCount++;
+        return [`${state.text}:${width}`];
+      },
+    };
+  });
+
+  const instance = {};
+  const theme = { heading: () => "" };
+
+  assert.deepEqual(
+    renderMarkdown(instance, { text: "cached", theme, defaultTextStyle: { bold: true } }, 24),
+    ["cached:24"],
+  );
+  assert.deepEqual(
+    renderMarkdown(instance, { text: "cached", theme, defaultTextStyle: { bold: true } }, 24),
+    ["cached:24"],
+  );
+  assert.equal(rendererCreationCount, 1);
+  assert.equal(renderCallCount, 1);
+
+  assert.deepEqual(
+    renderMarkdown(instance, { text: "cached", theme, defaultTextStyle: { bold: true } }, 48),
+    ["cached:48"],
+  );
+  assert.equal(rendererCreationCount, 1);
+  assert.equal(renderCallCount, 2);
+
+  assert.deepEqual(
+    renderMarkdown(instance, { text: "updated", theme, defaultTextStyle: { bold: true } }, 48),
+    ["updated:48"],
+  );
+  assert.equal(rendererCreationCount, 2);
+  assert.equal(renderCallCount, 3);
+});
+
+test("user message markdown rebuild guard bypasses oversized payloads", () => {
+  assert.equal(
+    shouldBypassUserMessageMarkdownRebuild({
+      text: "short message",
+      theme: {},
+    }),
+    false,
+  );
+  assert.equal(
+    shouldBypassUserMessageMarkdownRebuild({
+      text: `${"line\n".repeat(2000)}tail`,
+      theme: {},
+    }),
+    true,
+  );
+});
+
+test("user message renderer adds one top and bottom padding row inside the box", () => {
+  assert.deepEqual(addUserMessageVerticalPadding(["Ping"]), ["", "Ping", ""]);
+  assert.deepEqual(addUserMessageVerticalPadding(["Line 1", "Line 2"]), ["", "Line 1", "Line 2", ""]);
+});
+
+test("native user message renderer inserts one blank spacer line before the box", () => {
+  const prototype: PatchableUserMessagePrototype = {
+    render: () => ["Original user content"],
+  };
+
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => true);
+
+  const rendered = prototype.render(24);
+
+  assert.equal(rendered[0], "");
+  assert.match(rendered[1] ?? "", /^╭/);
+});
+
+test("native user message renderer wraps body at the padded content width", () => {
+  const contentWidth = 16;
+  const totalWidth = contentWidth + 4;
+  const message = `${"X".repeat(contentWidth)}YZ`;
+  const requestedWidths: number[] = [];
+  const prototype: PatchableUserMessagePrototype = {
+    render: (width: number): string[] => {
+      requestedWidths.push(width);
+      const lines: string[] = [];
+      for (let index = 0; index < message.length; index += width) {
+        lines.push(message.slice(index, index + width));
+      }
+      return lines;
+    },
+  };
+
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => true);
+
+  const rendered = prototype.render(totalWidth);
+  const borderedRows = rendered.filter((line) =>
+    line.startsWith("│") || line.startsWith("╭") || line.startsWith("╰"),
+  );
+
+  assert.equal(requestedWidths[0], contentWidth);
+  assert.ok(
+    rendered.some((line) => line.includes("YZ")),
+    "tail content should wrap instead of being clipped",
+  );
+  assert.ok(borderedRows.every((line) => visibleWidth(line) === totalWidth));
+});
+
+test("user message blank ansi lines are cleared before wrapping", () => {
+  assert.equal(normalizeUserMessageContentLine("\u001b[0m"), "");
+  assert.equal(normalizeUserMessageContentLine("   \u001b[31m\u001b[0m"), "");
+  assert.equal(normalizeUserMessageContentLine("\u001b]133;A\u0007   \u001b]133;B\u0007"), "");
+
+  const normalized = normalizeUserMessageContentLine("\u001b[31mhello\u001b[0m");
+  assert.match(normalized, /hello/);
+  assert.doesNotMatch(normalized, /\u001b\[0m/);
+
+  const withoutOsc = normalizeUserMessageContentLine("\u001b]133;A\u0007hello\u001b]133;B\u0007");
+  assert.equal(withoutOsc, "hello");
+
+  const hyperlink = "\u001b]8;;https://example.com\u001b\\link\u001b]8;;\u001b\\";
+  assert.equal(normalizeUserMessageContentLine(hyperlink), hyperlink);
+});
+
+test("user message background painting keeps trailing padding inside explicit background cells", () => {
+  const rendered = applyUserMessageBackground(
+    {
+      getBgAnsi: () => "\u001b[48;5;24m",
+    },
+    "\u001b[31mhello\u001b[0m   ",
+  );
+
+  assert.ok(rendered.startsWith("\u001b[48;5;24m"));
+  assert.match(rendered, /hello/);
+  assert.equal(rendered.indexOf("\u001b[49m"), rendered.lastIndexOf("\u001b[49m"));
+  assert.equal(rendered.slice(rendered.lastIndexOf("\u001b[49m") - 3, rendered.lastIndexOf("\u001b[49m")), "   ");
+  assert.doesNotMatch(rendered, /\u001b\[0m/);
+
+  const hyperlink = "\u001b]8;;https://example.com\u001b\\link\u001b]8;;\u001b\\";
+  const hyperlinkRendered = applyUserMessageBackground(undefined, hyperlink);
+  assert.equal(hyperlinkRendered, hyperlink);
+});
+
+test("user message background painting falls back to theme bg helper", () => {
+  const rendered = applyUserMessageBackground(
+    {
+      bg: (_color, text) => `bg(${text})`,
+    },
+    "\u001b[32mworld\u001b[49m",
+  );
+
+  assert.equal(rendered, "bg(\u001b[32mworld)");
+});
+
+test("user message content trims edge padding but preserves intentional interior breaks", () => {
+  assert.deepEqual(normalizeUserMessageContentLines(["", "hello", ""]), ["hello"]);
+  assert.deepEqual(normalizeUserMessageContentLines(["", "hello", "", "world", ""]), [
+    "hello",
+    "",
+    "world",
+  ]);
+  assert.deepEqual(normalizeUserMessageContentLines(["\u001b[0m", "   "]), []);
+  assert.deepEqual(
+    normalizeUserMessageContentLines([
+      "\u001b]133;A\u0007   ",
+      "hello",
+      "\u001b]133;B\u0007\u001b]133;C\u0007   ",
+    ]),
+    ["hello"],
+  );
+});
+
+test("collapsed diff hint shrinks to fit narrow panes", () => {
+  const hint = buildCollapsedDiffHintText(
+    {
+      remainingLines: 3970,
+      hiddenHunks: 1,
+    },
+    35,
+    codePointWidthOps,
+  );
+
+  assert.ok(codePointWidthOps.measure(hint) <= 35);
+  assert.match(hint, /3970/);
+  assert.doesNotMatch(hint, /Ctrl\+O/);
+});
+
+test("collapsed diff hint keeps full guidance when width allows", () => {
+  const hint = buildCollapsedDiffHintText(
+    {
+      remainingLines: 12,
+      hiddenHunks: 2,
+    },
+    80,
+    codePointWidthOps,
+  );
+
+  assert.equal(hint, "… (12 more diff lines • 2 more hunks • Ctrl+O to expand)");
+});
+
+test("line width clamp never returns text wider than the requested width", () => {
+  const clamped = clampRenderedLineToWidth(
+    "… (3970 more diff lines • Ctrl+O to expand)",
+    35,
+    codePointWidthOps,
+  );
+
+  assert.ok(codePointWidthOps.measure(clamped) <= 35);
+  assert.equal(clampRenderedLineToWidth("hello", 0, codePointWidthOps), "");
+});
+

package/dist/extensions/pi-tool-display/tests/user-message-box-performance-red.test.ts

@@ -0,0 +1,176 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  patchNativeUserMessagePrototype,
+  type PatchableUserMessagePrototype,
+  type UserMessageTheme,
+} from "../src/user-message-box-renderer.ts";
+
+function createCountingTheme(label: string): UserMessageTheme & { calls: string[] } {
+  const calls: string[] = [];
+  return {
+    calls,
+    fg(color: string, text: string): string {
+      calls.push(`${label}:fg:${color}:${text}`);
+      return `[${label}:${color}]${text}`;
+    },
+    bold(text: string): string {
+      calls.push(`${label}:bold:${text}`);
+      return `[${label}:bold]${text}`;
+    },
+  };
+}
+
+function markdownUserMessageInstance(text: string, theme: object = {}): { children: unknown[] } {
+  return {
+    children: [
+      {
+        text,
+        theme,
+      },
+    ],
+  };
+}
+
+function renderLineCount(lines: string[], needle: string): number {
+  return lines.filter((line) => line.includes(needle)).length;
+}
+
+// RED coverage for the reported long-session slowdown: these tests describe the
+// expected production fix but intentionally do not implement it here.
+
+test("native user message border render reuses final boxed output for identical rerenders", () => {
+  let originalRenderCount = 0;
+  const theme = createCountingTheme("stable");
+  const prototype: PatchableUserMessagePrototype = {
+    render(width: number) {
+      originalRenderCount++;
+      return [`stable body at ${width}`];
+    },
+  };
+  const instance = {};
+
+  patchNativeUserMessagePrototype(prototype, () => theme, () => true);
+
+  const first = prototype.render.call(instance, 42);
+  const themeCallsAfterFirstRender = theme.calls.length;
+  const second = prototype.render.call(instance, 42);
+
+  assert.equal(originalRenderCount, 1, "identical rerender should not call the original body renderer again");
+  assert.equal(theme.calls.length, themeCallsAfterFirstRender, "identical rerender should not recolor/rebuild border lines");
+  assert.equal(second, first, "identical rerender should return the cached final bordered string[]");
+});
+
+test("native user message final output cache invalidates by width and theme without rebuilding unchanged body", () => {
+  let originalRenderCount = 0;
+  let activeTheme = createCountingTheme("a");
+  const prototype: PatchableUserMessagePrototype = {
+    render(width: number) {
+      originalRenderCount++;
+      return [`body rendered for ${width}`];
+    },
+  };
+  const instance = {};
+
+  patchNativeUserMessagePrototype(prototype, () => activeTheme, () => true);
+
+  const width40ThemeA = prototype.render.call(instance, 40);
+  const width40ThemeAAgain = prototype.render.call(instance, 40);
+  const width50ThemeA = prototype.render.call(instance, 50);
+  activeTheme = createCountingTheme("b");
+  const width50ThemeB = prototype.render.call(instance, 50);
+
+  assert.equal(width40ThemeAAgain, width40ThemeA, "same width/theme should hit final output cache");
+  assert.notEqual(width50ThemeA, width40ThemeA, "different width must invalidate final output cache");
+  assert.notDeepEqual(width50ThemeB, width50ThemeA, "different theme must invalidate final output cache");
+  assert.equal(originalRenderCount, 2, "body renderer should run only once per distinct content width");
+});
+
+test("native user message final output cache does not return stale output after message state changes", () => {
+  const markdownTheme = {};
+  const instance = markdownUserMessageInstance("first message", markdownTheme);
+  const prototype: PatchableUserMessagePrototype = {
+    render() {
+      throw new Error("markdown child should provide body lines without falling back to original render");
+    },
+  };
+
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => true);
+
+  const first = prototype.render.call(instance, 48);
+  instance.children = [{ text: "second message", theme: markdownTheme }];
+  const second = prototype.render.call(instance, 48);
+
+  assert.notEqual(second, first, "changed markdown state should invalidate the final output cache reference");
+  assert.ok(first.some((line) => line.includes("first message")), "first render should include the original message");
+  assert.ok(second.some((line) => line.includes("second message")), "second render should include the changed message");
+  assert.equal(second.some((line) => line.includes("first message")), false, "changed message should not reuse stale boxed output");
+});
+
+test("native user message final output cache invalidates when the enabled state changes", () => {
+  let enabled = true;
+  const originalLines = ["disabled native fallback"];
+  const prototype: PatchableUserMessagePrototype = {
+    render() {
+      return originalLines;
+    },
+  };
+  const instance = {};
+
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => enabled);
+
+  const enabledRender = prototype.render.call(instance, 52);
+  const enabledRenderAgain = prototype.render.call(instance, 52);
+  enabled = false;
+  const disabledRender = prototype.render.call(instance, 52);
+
+  assert.equal(enabledRenderAgain, enabledRender, "same width/theme/enabled state should hit final output cache");
+  assert.equal(disabledRender, originalLines, "disabled native rendering must bypass any previously cached boxed output");
+  assert.notEqual(disabledRender, enabledRender, "enabled-state change should invalidate final output cache");
+});
+
+test("native user message skips custom boxing for markdown text over the character threshold", () => {
+  let originalRenderCount = 0;
+  const theme = createCountingTheme("huge-text");
+  const originalLines = ["huge body fallback"];
+  const instance = markdownUserMessageInstance("x".repeat(100_001));
+  const prototype: PatchableUserMessagePrototype = {
+    render(width: number) {
+      originalRenderCount++;
+      assert.equal(width, 80, "oversized messages should bypass native boxing before content-width shrinking");
+      return originalLines;
+    },
+  };
+
+  patchNativeUserMessagePrototype(prototype, () => theme, () => true);
+
+  const rendered = prototype.render.call(instance, 80);
+
+  assert.equal(originalRenderCount, 1);
+  assert.equal(rendered, originalLines, "oversized markdown text should return the original render output without custom boxing");
+  assert.equal(renderLineCount(rendered, "│"), 0, "oversized markdown text should avoid per-line custom box work");
+  assert.equal(theme.calls.length, 0, "oversized markdown text should not spend time coloring native border lines");
+});
+
+test("native user message skips custom boxing for markdown text over the line-count threshold", () => {
+  let originalRenderCount = 0;
+  const theme = createCountingTheme("huge-lines");
+  const originalLines = ["line-count fallback"];
+  const instance = markdownUserMessageInstance(`${"line\n".repeat(2000)}tail`);
+  const prototype: PatchableUserMessagePrototype = {
+    render(width: number) {
+      originalRenderCount++;
+      assert.equal(width, 72, "line-heavy messages should bypass native boxing before content-width shrinking");
+      return originalLines;
+    },
+  };
+
+  patchNativeUserMessagePrototype(prototype, () => theme, () => true);
+
+  const rendered = prototype.render.call(instance, 72);
+
+  assert.equal(originalRenderCount, 1);
+  assert.equal(rendered, originalLines, "line-heavy markdown should return the original render output without custom boxing");
+  assert.equal(renderLineCount(rendered, "│"), 0, "line-heavy markdown should avoid per-line custom box work");
+  assert.equal(theme.calls.length, 0, "line-heavy markdown should not spend time coloring native border lines");
+});