@butlerw/vellum 0.1.0

package/src/tui/utils/__tests__/bracketedPaste.test.ts

@@ -0,0 +1,231 @@
+/**
+ * Bracketed Paste Utilities Tests
+ *
+ * Tests for the bracketedPaste utility functions.
+ *
+ * @module @vellum/cli
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  disableBracketedPaste,
+  enableBracketedPaste,
+  extractPasteContent,
+  hasPasteEnd,
+  hasPasteStart,
+  PASTE_END,
+  PASTE_START,
+} from "../bracketedPaste.js";
+
+// =============================================================================
+// Mocks
+// =============================================================================
+
+const originalWrite = process.stdout.write;
+let writtenData: string[] = [];
+
+beforeEach(() => {
+  writtenData = [];
+  process.stdout.write = vi.fn((data: string | Uint8Array) => {
+    writtenData.push(typeof data === "string" ? data : data.toString());
+    return true;
+  }) as typeof process.stdout.write;
+});
+
+afterEach(() => {
+  process.stdout.write = originalWrite;
+});
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe("bracketedPaste utilities", () => {
+  describe("Constants", () => {
+    it("PASTE_START has correct ANSI sequence", () => {
+      expect(PASTE_START).toBe("\x1b[200~");
+    });
+
+    it("PASTE_END has correct ANSI sequence", () => {
+      expect(PASTE_END).toBe("\x1b[201~");
+    });
+  });
+
+  describe("enableBracketedPaste", () => {
+    it("writes correct ANSI enable sequence to stdout", () => {
+      enableBracketedPaste();
+
+      expect(process.stdout.write).toHaveBeenCalledTimes(1);
+      expect(writtenData[0]).toBe("\x1b[?2004h");
+    });
+
+    it("can be called multiple times", () => {
+      enableBracketedPaste();
+      enableBracketedPaste();
+
+      expect(process.stdout.write).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("disableBracketedPaste", () => {
+    it("writes correct ANSI disable sequence to stdout", () => {
+      disableBracketedPaste();
+
+      expect(process.stdout.write).toHaveBeenCalledTimes(1);
+      expect(writtenData[0]).toBe("\x1b[?2004l");
+    });
+
+    it("can be called multiple times", () => {
+      disableBracketedPaste();
+      disableBracketedPaste();
+
+      expect(process.stdout.write).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("hasPasteStart", () => {
+    it("returns true when paste start sequence is present", () => {
+      expect(hasPasteStart(`${PASTE_START}hello`)).toBe(true);
+    });
+
+    it("returns false when paste start sequence is absent", () => {
+      expect(hasPasteStart("hello world")).toBe(false);
+    });
+
+    it("returns true for sequence in middle of string", () => {
+      expect(hasPasteStart(`before${PASTE_START}after`)).toBe(true);
+    });
+
+    it("returns false for empty string", () => {
+      expect(hasPasteStart("")).toBe(false);
+    });
+
+    it("returns false for partial sequence", () => {
+      expect(hasPasteStart("\x1b[200")).toBe(false);
+    });
+  });
+
+  describe("hasPasteEnd", () => {
+    it("returns true when paste end sequence is present", () => {
+      expect(hasPasteEnd(`hello${PASTE_END}`)).toBe(true);
+    });
+
+    it("returns false when paste end sequence is absent", () => {
+      expect(hasPasteEnd("hello world")).toBe(false);
+    });
+
+    it("returns true for sequence in middle of string", () => {
+      expect(hasPasteEnd(`before${PASTE_END}after`)).toBe(true);
+    });
+
+    it("returns false for empty string", () => {
+      expect(hasPasteEnd("")).toBe(false);
+    });
+
+    it("returns false for partial sequence", () => {
+      expect(hasPasteEnd("\x1b[201")).toBe(false);
+    });
+  });
+
+  describe("extractPasteContent", () => {
+    it("extracts complete paste content", () => {
+      const input = `${PASTE_START}pasted text${PASTE_END}`;
+      const result = extractPasteContent(input);
+
+      expect(result.content).toBe("pasted text");
+      expect(result.complete).toBe(true);
+      expect(result.remaining).toBe("");
+    });
+
+    it("extracts content with text before paste", () => {
+      const input = `before${PASTE_START}pasted${PASTE_END}`;
+      const result = extractPasteContent(input);
+
+      expect(result.content).toBe("pasted");
+      expect(result.complete).toBe(true);
+      expect(result.remaining).toBe("before");
+    });
+
+    it("extracts content with text after paste", () => {
+      const input = `${PASTE_START}pasted${PASTE_END}after`;
+      const result = extractPasteContent(input);
+
+      expect(result.content).toBe("pasted");
+      expect(result.complete).toBe(true);
+      expect(result.remaining).toBe("after");
+    });
+
+    it("extracts content with text before and after paste", () => {
+      const input = `before${PASTE_START}pasted${PASTE_END}after`;
+      const result = extractPasteContent(input);
+
+      expect(result.content).toBe("pasted");
+      expect(result.complete).toBe(true);
+      expect(result.remaining).toBe("beforeafter");
+    });
+
+    it("handles incomplete paste (no end sequence)", () => {
+      const input = `${PASTE_START}incomplete paste`;
+      const result = extractPasteContent(input);
+
+      expect(result.content).toBe("incomplete paste");
+      expect(result.complete).toBe(false);
+      expect(result.remaining).toBe("");
+    });
+
+    it("handles incomplete paste with text before", () => {
+      const input = `before${PASTE_START}incomplete`;
+      const result = extractPasteContent(input);
+
+      expect(result.content).toBe("incomplete");
+      expect(result.complete).toBe(false);
+      expect(result.remaining).toBe("before");
+    });
+
+    it("returns empty for no paste sequence", () => {
+      const input = "no paste here";
+      const result = extractPasteContent(input);
+
+      expect(result.content).toBe("");
+      expect(result.complete).toBe(false);
+      expect(result.remaining).toBe("no paste here");
+    });
+
+    it("handles empty paste content", () => {
+      const input = `${PASTE_START}${PASTE_END}`;
+      const result = extractPasteContent(input);
+
+      expect(result.content).toBe("");
+      expect(result.complete).toBe(true);
+      expect(result.remaining).toBe("");
+    });
+
+    it("handles multiline paste content", () => {
+      const multilineContent = "line1\nline2\nline3";
+      const input = `${PASTE_START}${multilineContent}${PASTE_END}`;
+      const result = extractPasteContent(input);
+
+      expect(result.content).toBe(multilineContent);
+      expect(result.complete).toBe(true);
+      expect(result.remaining).toBe("");
+    });
+
+    it("handles paste content with special characters", () => {
+      const specialContent = '{"key": "value", "arr": [1, 2, 3]}';
+      const input = `${PASTE_START}${specialContent}${PASTE_END}`;
+      const result = extractPasteContent(input);
+
+      expect(result.content).toBe(specialContent);
+      expect(result.complete).toBe(true);
+    });
+
+    it("handles paste content with unicode", () => {
+      const unicodeContent = "你好世界 🎉 émojis";
+      const input = `${PASTE_START}${unicodeContent}${PASTE_END}`;
+      const result = extractPasteContent(input);
+
+      expect(result.content).toBe(unicodeContent);
+      expect(result.complete).toBe(true);
+    });
+  });
+});

package/src/tui/utils/__tests__/heightEstimator.test.ts

@@ -0,0 +1,157 @@
+/**
+ * Height Estimator Utilities Tests (T011)
+ *
+ * Tests for upper-bound height estimation.
+ * Note: Estimates are INTENTIONALLY CONSERVATIVE (larger) to prevent terminal overflow.
+ *
+ * @module tui/utils/__tests__/heightEstimator.test
+ */
+
+import { describe, expect, it } from "vitest";
+import type { Message } from "../../context/MessagesContext.js";
+import {
+  DEFAULT_ESTIMATED_ITEM_HEIGHT,
+  estimateMessageHeight,
+  estimateWrappedLineCount,
+  HEIGHT_SAFETY_MARGIN,
+  MIN_MESSAGE_HEIGHT,
+  THINKING_HEADER_UPPER_BOUND,
+  TOOL_CALL_DIFF_UPPER_BOUND,
+  TOOL_CALL_UPPER_BOUND,
+} from "../heightEstimator.js";
+
+describe("estimateWrappedLineCount", () => {
+  it("returns 1 for empty string", () => {
+    expect(estimateWrappedLineCount("", 80)).toBe(1);
+  });
+
+  it("returns 1 for short single-line text", () => {
+    expect(estimateWrappedLineCount("hello", 80)).toBe(1);
+  });
+
+  it("calculates wrapped lines for long text", () => {
+    const text = "a".repeat(160);
+    expect(estimateWrappedLineCount(text, 80)).toBe(2);
+  });
+
+  it("handles multi-line text", () => {
+    const text = "line1\nline2\nline3";
+    expect(estimateWrappedLineCount(text, 80)).toBe(3);
+  });
+
+  it("handles multi-line with wrapping", () => {
+    const text = `${"a".repeat(100)}\n${"b".repeat(50)}`;
+    expect(estimateWrappedLineCount(text, 80)).toBe(3); // 2 + 1
+  });
+});
+
+describe("estimateWrappedLineCount - CJK handling", () => {
+  it("counts CJK characters as 2 columns each", () => {
+    // 10 CJK chars = 20 columns, width 80 → 1 line
+    expect(estimateWrappedLineCount("中文字符测试内容啊啊", 80)).toBe(1);
+    // 40 CJK chars = 80 columns, width 40 → 2 lines
+    expect(estimateWrappedLineCount("中".repeat(40), 40)).toBe(2);
+  });
+});
+
+describe("estimateMessageHeight - Upper Bound Estimation", () => {
+  const baseMessage: Message = {
+    id: "1",
+    role: "assistant",
+    content: "Hello world",
+    timestamp: new Date(),
+  };
+
+  it("returns at least MIN_MESSAGE_HEIGHT", () => {
+    const height = estimateMessageHeight(baseMessage, { width: 80 });
+    // Upper bound: header(2) + content(1) + margin(2) + safety(2) = 7, min=4
+    expect(height).toBeGreaterThanOrEqual(MIN_MESSAGE_HEIGHT);
+  });
+
+  it("includes THINKING_HEADER_UPPER_BOUND for thinking blocks", () => {
+    const msg: Message = { ...baseMessage, thinking: "Let me think..." };
+    const height = estimateMessageHeight(msg, { width: 80 });
+    // With thinking: header(2) + content(1) + thinking_header(4) + thinking(1) + margin(2) + safety(2) = 12
+    expect(height).toBeGreaterThanOrEqual(THINKING_HEADER_UPPER_BOUND);
+    expect(height).toBeGreaterThan(MIN_MESSAGE_HEIGHT);
+  });
+
+  it("uses TOOL_CALL_UPPER_BOUND for each tool call", () => {
+    const msgWithOneTool: Message = {
+      ...baseMessage,
+      toolCalls: [{ id: "t1", name: "read_file", arguments: {}, status: "completed" }],
+    };
+    const msgWithTwoTools: Message = {
+      ...baseMessage,
+      toolCalls: [
+        { id: "t1", name: "read_file", arguments: {}, status: "completed" },
+        { id: "t2", name: "write_file", arguments: {}, status: "running" },
+      ],
+    };
+    const height1 = estimateMessageHeight(msgWithOneTool, { width: 80 });
+    const height2 = estimateMessageHeight(msgWithTwoTools, { width: 80 });
+    // Each tool adds TOOL_CALL_UPPER_BOUND lines
+    expect(height2 - height1).toBe(TOOL_CALL_UPPER_BOUND);
+  });
+
+  it("uses TOOL_CALL_DIFF_UPPER_BOUND when diff metadata is present", () => {
+    const diffMeta = {
+      diff: "--- a/file.txt\n+++ b/file.txt\n@@ -1 +1 @@\n-foo\n+bar",
+      additions: 1,
+      deletions: 1,
+    };
+    const msgWithoutDiff: Message = {
+      ...baseMessage,
+      toolCalls: [{ id: "t1", name: "apply_patch", arguments: {}, status: "completed" }],
+    };
+    const msgWithDiff: Message = {
+      ...baseMessage,
+      toolCalls: [
+        {
+          id: "t1",
+          name: "apply_patch",
+          arguments: {},
+          status: "completed",
+          result: { diffMeta },
+        },
+      ],
+    };
+    const heightWithoutDiff = estimateMessageHeight(msgWithoutDiff, { width: 80 });
+    const heightWithDiff = estimateMessageHeight(msgWithDiff, { width: 80 });
+    expect(heightWithDiff - heightWithoutDiff).toBe(
+      TOOL_CALL_DIFF_UPPER_BOUND - TOOL_CALL_UPPER_BOUND
+    );
+  });
+
+  it("handles tool_group messages with upper bound per tool", () => {
+    const msg: Message = {
+      ...baseMessage,
+      role: "tool_group",
+      toolCalls: [
+        { id: "t1", name: "tool1", arguments: {}, status: "completed" },
+        { id: "t2", name: "tool2", arguments: {}, status: "completed" },
+      ],
+    };
+    const height = estimateMessageHeight(msg, { width: 80 });
+    // tool_group: 2 tools * TOOL_CALL_UPPER_BOUND + margin(2)
+    expect(height).toBeGreaterThanOrEqual(2 * TOOL_CALL_UPPER_BOUND);
+  });
+
+  it("excludes tool calls when configured", () => {
+    const msg: Message = {
+      ...baseMessage,
+      toolCalls: [{ id: "t1", name: "read_file", arguments: {}, status: "completed" }],
+    };
+    const heightWithTools = estimateMessageHeight(msg, { width: 80 });
+    const heightWithoutTools = estimateMessageHeight(msg, { width: 80, includeToolCalls: false });
+    // Without tools should be smaller
+    expect(heightWithoutTools).toBeLessThan(heightWithTools);
+    expect(heightWithoutTools).toBeGreaterThanOrEqual(MIN_MESSAGE_HEIGHT);
+  });
+
+  it("includes HEIGHT_SAFETY_MARGIN in all estimates", () => {
+    // Safety margin ensures we never under-estimate
+    expect(HEIGHT_SAFETY_MARGIN).toBeGreaterThan(0);
+    expect(DEFAULT_ESTIMATED_ITEM_HEIGHT).toBeGreaterThanOrEqual(MIN_MESSAGE_HEIGHT);
+  });
+});

package/src/tui/utils/__tests__/text-width.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Tests for Text Width Utilities
+ */
+import { describe, expect, it } from "vitest";
+import {
+  countLines,
+  getVisualWidth,
+  padToWidth,
+  splitLines,
+  truncateToWidth,
+  wrapToWidth,
+} from "../text-width.js";
+
+describe("text-width", () => {
+  describe("getVisualWidth", () => {
+    it("measures ASCII text correctly", () => {
+      expect(getVisualWidth("hello")).toBe(5);
+      expect(getVisualWidth("test")).toBe(4);
+    });
+
+    it("handles empty string", () => {
+      expect(getVisualWidth("")).toBe(0);
+    });
+
+    it("measures CJK characters as width 2", () => {
+      expect(getVisualWidth("你好")).toBe(4); // 2 chars × 2 width
+      expect(getVisualWidth("日本")).toBe(4);
+    });
+
+    it("measures emojis as width 2", () => {
+      expect(getVisualWidth("👋")).toBe(2);
+    });
+
+    it("ANSI escape sequences have zero width", () => {
+      expect(getVisualWidth("\x1b[31mred\x1b[0m")).toBe(3);
+      expect(getVisualWidth("\x1b[1mbold\x1b[0m")).toBe(4);
+    });
+  });
+
+  describe("truncateToWidth", () => {
+    it("returns original if within maxWidth", () => {
+      expect(truncateToWidth("Short", 10)).toBe("Short");
+      expect(truncateToWidth("Hi", 5)).toBe("Hi");
+    });
+
+    it("truncates and adds ellipsis when too long", () => {
+      expect(truncateToWidth("Hello World", 8)).toBe("Hello W…");
+    });
+
+    it("handles empty string", () => {
+      expect(truncateToWidth("", 10)).toBe("");
+    });
+
+    it("handles zero maxWidth", () => {
+      const result = truncateToWidth("Hello", 0);
+      expect(getVisualWidth(result)).toBeLessThanOrEqual(1);
+    });
+
+    it("handles CJK text", () => {
+      const result = truncateToWidth("你好世界", 5);
+      expect(getVisualWidth(result)).toBeLessThanOrEqual(5);
+    });
+
+    it("uses custom ellipsis", () => {
+      expect(truncateToWidth("Hello World", 8, "...")).toBe("Hello...");
+    });
+  });
+
+  describe("padToWidth", () => {
+    it("pads left-aligned text", () => {
+      expect(padToWidth("Hi", 10, "left")).toBe("Hi        ");
+    });
+
+    it("pads right-aligned text", () => {
+      expect(padToWidth("Hi", 10, "right")).toBe("        Hi");
+    });
+
+    it("pads center-aligned text", () => {
+      expect(padToWidth("Hi", 10, "center")).toBe("    Hi    ");
+    });
+
+    it("handles odd padding for center alignment", () => {
+      const result = padToWidth("Hi", 9, "center");
+      expect(result.length).toBe(9);
+    });
+
+    it("returns original if text width >= target", () => {
+      expect(padToWidth("HelloWorld", 5, "left")).toBe("HelloWorld");
+    });
+
+    it("handles empty string", () => {
+      expect(padToWidth("", 5, "left")).toBe("     ");
+    });
+
+    it("defaults to left alignment", () => {
+      expect(padToWidth("Hi", 5)).toBe("Hi   ");
+    });
+
+    it("handles CJK text", () => {
+      const result = padToWidth("你好", 8, "center");
+      expect(getVisualWidth(result)).toBe(8);
+    });
+  });
+
+  describe("wrapToWidth", () => {
+    it("wraps long lines at word boundaries", () => {
+      const result = wrapToWidth("This is a long line that needs wrapping", 20);
+      expect(result).toContain("\n");
+    });
+
+    it("handles empty string", () => {
+      expect(wrapToWidth("", 20)).toBe("");
+    });
+
+    it("hard wraps with option", () => {
+      const result = wrapToWidth("LongWordThatCantBreak", 10, { hard: true });
+      expect(result).toContain("\n");
+    });
+
+    it("preserves short lines", () => {
+      expect(wrapToWidth("Hi", 10)).toBe("Hi");
+    });
+  });
+
+  describe("splitLines", () => {
+    it("returns array of lines", () => {
+      const lines = splitLines("Hello World", 6);
+      expect(Array.isArray(lines)).toBe(true);
+      expect(lines.length).toBeGreaterThan(1);
+    });
+
+    it("handles single line that fits", () => {
+      const lines = splitLines("Hi", 10);
+      expect(lines).toHaveLength(1);
+      expect(lines[0]).toBe("Hi");
+    });
+
+    it("handles empty string", () => {
+      const lines = splitLines("", 10);
+      expect(lines).toHaveLength(1);
+      expect(lines[0]).toBe("");
+    });
+  });
+
+  describe("countLines", () => {
+    it("counts lines after wrapping", () => {
+      expect(countLines("Hello World", 6)).toBeGreaterThan(1);
+    });
+
+    it("returns 1 for short text", () => {
+      expect(countLines("Hi", 10)).toBe(1);
+    });
+
+    it("returns 1 for empty string", () => {
+      expect(countLines("", 10)).toBe(1);
+    });
+  });
+});