@golba98/codexa 1.0.1

package/src/ui/inputBuffer.test.ts

@@ -0,0 +1,151 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  clampScrollToCursor,
+  createInputViewport,
+  deleteInputBackward,
+  deleteInputForward,
+  insertInputText,
+  locateCursor,
+  moveCursorLeft,
+  moveCursorRight,
+  normalizeInputText,
+  stripMouseEscapes,
+  wrapInputRows,
+} from "./inputBuffer.js";
+
+test("normalizes windows line endings for the composer buffer", () => {
+  assert.equal(normalizeInputText("a\r\nb\rc"), "a\nb\nc");
+});
+
+test("wraps multiline input into stable viewport rows", () => {
+  const rows = wrapInputRows("alpha\nbeta gamma", 5);
+  assert.deepEqual(rows.map((row) => row.text), ["alpha", "beta ", "gamma"]);
+  assert.deepEqual(rows.map((row) => row.breakType), ["hard", "soft", "end"]);
+});
+
+test("keeps the cursor visible by scrolling the composer viewport", () => {
+  assert.equal(clampScrollToCursor(0, 7, 4), 4);
+});
+
+test("keeps cursor mapping stable at hard newlines and soft wrap boundaries", () => {
+  const multilineRows = wrapInputRows("alpha\nbeta", 20);
+  assert.deepEqual(locateCursor(multilineRows, 5), { row: 0, column: 5 });
+  assert.deepEqual(locateCursor(multilineRows, 6), { row: 1, column: 0 });
+
+  const wrappedRows = wrapInputRows("alpha beta", 5);
+  assert.deepEqual(locateCursor(wrappedRows, 5), { row: 0, column: 5 });
+  assert.deepEqual(locateCursor(wrappedRows, 6), { row: 1, column: 1 });
+});
+
+test("uses code-point-safe cursor movement and deletion", () => {
+  const text = "A😀B";
+  assert.equal(moveCursorRight(text, 0), 1);
+  assert.equal(moveCursorRight(text, 1), 3);
+  assert.equal(moveCursorLeft(text, 3), 1);
+
+  const inserted = insertInputText({ value: "A", cursorOffset: 1, text: "\nB" });
+  assert.deepEqual(inserted, { value: "A\nB", cursorOffset: 3 });
+
+  const deleted = deleteInputBackward({ value: text, cursorOffset: 3 });
+  assert.deepEqual(deleted, { value: "AB", cursorOffset: 1 });
+
+  const forwardDeleted = deleteInputForward({ value: text, cursorOffset: 1 });
+  assert.deepEqual(forwardDeleted, { value: "AB", cursorOffset: 1 });
+});
+
+test("creates a bounded input viewport for large pasted content", () => {
+  const viewport = createInputViewport({
+    text: Array.from({ length: 12 }, (_, index) => `line-${index + 1}`).join("\n"),
+    cursorOffset: "line-1\nline-2\nline-3\nline-4\nline-5\nline-6\nline-7\nline-8\nline-9\nline-10\nline-11\nline-12".length,
+    width: 20,
+    maxVisibleRows: 4,
+  });
+
+  assert.equal(viewport.visibleRows.length, 4);
+  assert.equal(viewport.visibleRows[0]?.text, "line-9");
+  assert.equal(viewport.visibleRows[3]?.text, "line-12");
+});
+
+test("reclamps scroll state when resize reduces the wrapped row count", () => {
+  const narrowViewport = createInputViewport({
+    text: "alpha beta gamma delta epsilon",
+    cursorOffset: "alpha beta gamma delta epsilon".length,
+    width: 5,
+    maxVisibleRows: 2,
+  });
+
+  const wideViewport = createInputViewport({
+    text: "alpha beta gamma delta epsilon",
+    cursorOffset: "alpha beta gamma delta epsilon".length,
+    width: 40,
+    maxVisibleRows: 2,
+    scrollRow: narrowViewport.scrollRow,
+  });
+
+  assert.equal(narrowViewport.scrollRow > 0, true);
+  assert.equal(wideViewport.scrollRow, 0);
+  assert.deepEqual(wideViewport.visibleRows.map((row) => row.text), ["alpha beta gamma delta epsilon"]);
+});
+
+test("strips leaked SGR mouse escape sequence fragments from input", () => {
+  const leaked = "[<0;26;24M[<0;26;24m";
+  assert.equal(normalizeInputText(leaked), "");
+
+  const partial = "text[<0;26;24Mmore";
+  assert.equal(normalizeInputText(partial), "textmore");
+});
+
+test("stripMouseEscapes: removes complete SGR sequences (ESC-prefixed)", () => {
+  assert.equal(stripMouseEscapes("\x1b[<0;83;19M"), "");
+  assert.equal(stripMouseEscapes("\x1b[<64;83;19M"), "");
+  assert.equal(stripMouseEscapes("\x1b[<64;83;19m"), "");  // lowercase m
+});
+
+test("stripMouseEscapes: removes leaked SGR fragments (ESC already stripped by readline)", () => {
+  assert.equal(stripMouseEscapes("[<0;83;19M"), "");
+});
+
+test("stripMouseEscapes: strips mouse sequences embedded in surrounding text", () => {
+  assert.equal(stripMouseEscapes("hello\x1b[<0;83;19M"), "hello");
+  assert.equal(stripMouseEscapes("\x1b[<0;83;19Mhello"), "hello");
+  assert.equal(stripMouseEscapes("hello[<64;83;19Mworld"), "helloworld");
+});
+
+test("stripMouseEscapes: preserves normal text and returns it unchanged", () => {
+  assert.equal(stripMouseEscapes("hello world"), "hello world");
+  assert.equal(stripMouseEscapes("git status"), "git status");
+  assert.equal(stripMouseEscapes(""), "");
+  assert.equal(stripMouseEscapes("I"), "I");
+  assert.equal(stripMouseEscapes("yes"), "yes");
+});
+
+// NOTE: Partial chunk splitting (e.g. "\x1b[<0;" then "83;19M" as two separate writes)
+// is not filterable at the string level — each chunk alone does not match the pattern.
+// Robust partial-chunk handling requires stateful stdin buffering (not implemented here
+// or in BottomComposer). In practice, terminals send mouse sequences as atomic stdin
+// writes so this case does not arise in normal usage.
+
+test("robustness: rapid sequential typing and deletion", () => {
+  let state = { value: "", cursorOffset: 0 };
+  
+  // Simulate typing "hello"
+  for (const char of "hello") {
+    state = insertInputText({ ...state, text: char });
+  }
+  assert.deepEqual(state, { value: "hello", cursorOffset: 5 });
+
+  // Simulate backspacing "o" and "l"
+  state = deleteInputBackward(state);
+  state = deleteInputBackward(state);
+  assert.deepEqual(state, { value: "hel", cursorOffset: 3 });
+
+  // Simulate inserting "p" in the middle
+  state.cursorOffset = 2; // after "e"
+  state = insertInputText({ ...state, text: "p" });
+  assert.deepEqual(state, { value: "hepl", cursorOffset: 3 });
+
+  // Simulate forward delete of "l"
+  state = deleteInputForward(state);
+  assert.deepEqual(state, { value: "hep", cursorOffset: 3 });
+});

package/src/ui/inputBuffer.ts

@@ -0,0 +1,203 @@
+import type { WrappedTextRow } from "./textLayout.js";
+import { getTextWidth, normalizeLineBreaks, wrapTextRows } from "./textLayout.js";
+import { sanitizeTerminalInput } from "../core/terminal/terminalSanitize.js";
+
+export type WrappedInputRow = WrappedTextRow;
+
+export interface InputViewport {
+  rows: WrappedInputRow[];
+  visibleRows: WrappedInputRow[];
+  cursorRow: number;
+  cursorColumn: number;
+  scrollRow: number;
+}
+
+function isHighSurrogate(code: number): boolean {
+  return code >= 0xd800 && code <= 0xdbff;
+}
+
+function isLowSurrogate(code: number): boolean {
+  return code >= 0xdc00 && code <= 0xdfff;
+}
+
+const LEAKED_SGR_MOUSE_PATTERN = /(?:\x1b)?\[<\d+;\d+;\d+[Mm]/g;
+
+export function normalizeInputText(text: string): string {
+  if (!text) return "";
+  // Strip out leaked SGR mouse coordinates that might have been emitted by
+  // the terminal without their ESC prefix (swallowed by readline).
+  const withoutMouse = text.replace(LEAKED_SGR_MOUSE_PATTERN, "");
+  return normalizeLineBreaks(sanitizeTerminalInput(withoutMouse));
+}
+
+export function stripMouseEscapes(input: string): string {
+  return input.replace(LEAKED_SGR_MOUSE_PATTERN, "");
+}
+
+export function normalizeCursorOffset(text: string, cursorOffset: number): number {
+  const safeCursor = Math.max(0, Math.min(cursorOffset, text.length));
+
+  if (
+    safeCursor > 0
+    && safeCursor < text.length
+    && isHighSurrogate(text.charCodeAt(safeCursor - 1))
+    && isLowSurrogate(text.charCodeAt(safeCursor))
+  ) {
+    return safeCursor - 1;
+  }
+
+  return safeCursor;
+}
+
+// ─── Cursor movement ─────────────────────────────────────────────────────────
+
+export function moveCursorLeft(text: string, cursorOffset: number): number {
+  const safeCursor = normalizeCursorOffset(text, cursorOffset);
+  if (safeCursor <= 0) return 0;
+
+  let nextCursor = safeCursor - 1;
+  if (nextCursor > 0 && isLowSurrogate(text.charCodeAt(nextCursor)) && isHighSurrogate(text.charCodeAt(nextCursor - 1))) {
+    nextCursor -= 1;
+  }
+
+  return nextCursor;
+}
+
+export function moveCursorRight(text: string, cursorOffset: number): number {
+  const safeCursor = normalizeCursorOffset(text, cursorOffset);
+  if (safeCursor >= text.length) return text.length;
+
+  if (
+    isHighSurrogate(text.charCodeAt(safeCursor))
+    && safeCursor + 1 < text.length
+    && isLowSurrogate(text.charCodeAt(safeCursor + 1))
+  ) {
+    return safeCursor + 2;
+  }
+
+  return safeCursor + 1;
+}
+
+// ─── Text mutations ───────────────────────────────────────────────────────────
+
+export function insertInputText(params: {
+  value: string;
+  cursorOffset: number;
+  text: string;
+}): { value: string; cursorOffset: number } {
+  const value = normalizeInputText(params.value);
+  const safeCursor = normalizeCursorOffset(value, params.cursorOffset);
+  const insertedText = normalizeInputText(params.text);
+  return {
+    value: value.slice(0, safeCursor) + insertedText + value.slice(safeCursor),
+    cursorOffset: safeCursor + insertedText.length,
+  };
+}
+
+export function deleteInputBackward(params: {
+  value: string;
+  cursorOffset: number;
+}): { value: string; cursorOffset: number } {
+  const value = normalizeInputText(params.value);
+  const safeCursor = normalizeCursorOffset(value, params.cursorOffset);
+  
+  if (safeCursor <= 0) {
+    return { value, cursorOffset: 0 };
+  }
+
+  const previousCursor = moveCursorLeft(value, safeCursor);
+  return {
+    value: value.slice(0, previousCursor) + value.slice(safeCursor),
+    cursorOffset: previousCursor,
+  };
+}
+
+export function deleteInputForward(params: {
+  value: string;
+  cursorOffset: number;
+}): { value: string; cursorOffset: number } {
+  const value = normalizeInputText(params.value);
+  const safeCursor = normalizeCursorOffset(value, params.cursorOffset);
+
+  if (safeCursor >= value.length) {
+    return { value, cursorOffset: safeCursor };
+  }
+
+  const nextCursor = moveCursorRight(value, safeCursor);
+  return {
+    value: value.slice(0, safeCursor) + value.slice(nextCursor),
+    cursorOffset: safeCursor,
+  };
+}
+
+// ─── Viewport ────────────────────────────────────────────────────────────────
+
+export function wrapInputRows(text: string, width: number): WrappedInputRow[] {
+  return wrapTextRows(normalizeInputText(text), width);
+}
+
+export function locateCursor(rows: WrappedInputRow[], cursorOffset: number) {
+  const safeCursor = Math.max(0, cursorOffset);
+
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index]!;
+    if (safeCursor <= row.end) {
+      const relative = Math.max(0, Math.min(safeCursor, row.end) - row.start);
+      return {
+        row: index,
+        column: getTextWidth(row.text.slice(0, relative)),
+      };
+    }
+  }
+
+  const lastRow = rows[rows.length - 1]!;
+  return {
+    row: rows.length - 1,
+    column: getTextWidth(lastRow.text),
+  };
+}
+
+export function clampScrollToCursor(
+  scrollRow: number,
+  cursorRow: number,
+  visibleRowCount: number,
+  totalRowCount = cursorRow + 1,
+): number {
+  const safeVisibleRows = Math.max(1, visibleRowCount);
+  const maxScroll = Math.max(0, totalRowCount - safeVisibleRows);
+  let nextScrollRow = Math.max(0, Math.min(scrollRow, maxScroll));
+
+  if (cursorRow < nextScrollRow) {
+    nextScrollRow = cursorRow;
+  }
+
+  if (cursorRow >= nextScrollRow + safeVisibleRows) {
+    nextScrollRow = cursorRow - safeVisibleRows + 1;
+  }
+
+  return Math.max(0, Math.min(nextScrollRow, maxScroll));
+}
+
+export function createInputViewport(params: {
+  text: string;
+  cursorOffset: number;
+  width: number;
+  maxVisibleRows: number;
+  scrollRow?: number;
+}): InputViewport {
+  const rows = wrapInputRows(params.text, params.width);
+  const cursor = locateCursor(rows, params.cursorOffset);
+  const nextScrollRow = clampScrollToCursor(params.scrollRow ?? 0, cursor.row, params.maxVisibleRows, rows.length);
+
+  return {
+    rows,
+    visibleRows: rows.slice(nextScrollRow, nextScrollRow + Math.max(1, params.maxVisibleRows)),
+    cursorRow: cursor.row,
+    cursorColumn: cursor.column,
+    scrollRow: nextScrollRow,
+  };
+}
+
+export function getComposerBodyWidth(totalWidth: number): number {
+  return Math.max(4, totalWidth - 4);
+}

package/src/ui/layout.test.ts

@@ -0,0 +1,145 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  advanceTerminalViewport,
+  clampVisualText,
+  createTerminalViewport,
+  createLayoutSnapshot,
+  getShellHeight,
+  getShellWidth,
+  getUsableShellWidth,
+  getVisualWidth,
+  resolveStartupHeaderMode,
+} from "./layout.js";
+import { getHeaderHeroLayout, measureTopHeaderRows } from "./TopHeader.js";
+
+test("leaves a one-column gutter to avoid edge-triggered scrollbars", () => {
+  assert.equal(getShellWidth(120), 119);
+  assert.equal(getShellWidth(80), 79);
+});
+
+test("keeps a sensible minimum shell width on tiny terminals", () => {
+  assert.equal(getShellWidth(20), 20);
+  assert.equal(getShellWidth(10), 20);
+  assert.equal(getShellWidth(undefined), 119);
+});
+
+test("derives usable shell width from the guttered viewport width", () => {
+  assert.equal(getUsableShellWidth(120, 6), 113);
+  assert.equal(getUsableShellWidth(20, 30), 1);
+});
+
+test("leaves a one-row gutter to avoid edge-triggered bottom scrolling", () => {
+  assert.equal(getShellHeight(40), 39);
+  assert.equal(getShellHeight(24), 23);
+});
+
+test("keeps a sensible minimum shell height on tiny terminals", () => {
+  assert.equal(getShellHeight(10), 10);
+  assert.equal(getShellHeight(5), 10);
+  assert.equal(getShellHeight(undefined), 23);
+});
+
+test("keeps breakpoint modes stable at the edges", () => {
+  assert.equal(createLayoutSnapshot(110, 24).mode, "full");
+  assert.equal(createLayoutSnapshot(109, 24).mode, "compact");
+  assert.equal(createLayoutSnapshot(60, 24).mode, "compact");
+  assert.equal(createLayoutSnapshot(59, 24).mode, "micro");
+});
+
+test("chooses startup header mode from measured row budget", () => {
+  assert.equal(resolveStartupHeaderMode({
+    cols: 120,
+    rows: 30,
+    introRows: 7,
+    composerRows: 6,
+  }), "large");
+
+  assert.equal(resolveStartupHeaderMode({
+    cols: 120,
+    rows: 16,
+    introRows: 7,
+    composerRows: 6,
+  }), "compact");
+
+  assert.equal(resolveStartupHeaderMode({
+    cols: 100,
+    rows: 24,
+    introRows: 7,
+    composerRows: 5,
+  }), "compact");
+
+  assert.equal(resolveStartupHeaderMode({
+    cols: 39,
+    rows: 24,
+    introRows: 7,
+    composerRows: 5,
+  }), "tiny");
+
+  assert.equal(resolveStartupHeaderMode({
+    cols: 100,
+    rows: 13,
+    introRows: 7,
+    composerRows: 5,
+  }), "tiny");
+});
+
+test("measures the header rows for full and compact layouts", () => {
+  assert.equal(measureTopHeaderRows(createLayoutSnapshot(120, 30)), 8);
+  assert.equal(measureTopHeaderRows(createLayoutSnapshot(80, 24)), 1);
+});
+
+test("header hero switches from stacked to wide only when metadata has room", () => {
+  assert.equal(getHeaderHeroLayout(createLayoutSnapshot(110, 30)).mode, "stacked");
+  assert.equal(getHeaderHeroLayout(createLayoutSnapshot(130, 30)).mode, "wide");
+});
+
+test("preserves the previous layout when resize values are invalid", () => {
+  const previous = createLayoutSnapshot(80, 30);
+  const next = createLayoutSnapshot(0, -1, previous);
+
+  assert.deepEqual(next, previous);
+});
+
+test("marks undersized restore samples as unstable without discarding the last stable layout", () => {
+  const stable = createTerminalViewport(120, 40);
+  const invalidSamples = [
+    advanceTerminalViewport(stable, 1, 1),
+    advanceTerminalViewport(stable, 2, 1),
+    advanceTerminalViewport(stable, 1, 24),
+    advanceTerminalViewport(stable, 24, 1),
+    // Medium-invalid: pass old <=1 check but fail MIN_VIEWPORT thresholds
+    advanceTerminalViewport(stable, 15, 8),
+    advanceTerminalViewport(stable, 19, 24),
+    advanceTerminalViewport(stable, 120, 9),
+  ];
+
+  for (const sample of invalidSamples) {
+    assert.equal(sample.unstable, true);
+    assert.equal(sample.cols, stable.cols);
+    assert.equal(sample.rows, stable.rows);
+    assert.equal(sample.layoutEpoch, stable.layoutEpoch);
+  }
+});
+
+test("bumps the layout epoch when the terminal recovers from an unstable restore", () => {
+  const stable = createTerminalViewport(120, 40);
+  const unstable = advanceTerminalViewport(stable, 1, 1);
+  const recovered = advanceTerminalViewport(unstable, 100, 30);
+
+  assert.equal(unstable.unstable, true);
+  assert.equal(recovered.unstable, false);
+  assert.equal(recovered.cols, 100);
+  assert.equal(recovered.rows, 30);
+  assert.equal(recovered.layoutEpoch, stable.layoutEpoch + 1);
+});
+
+test("measures visual width instead of raw string length", () => {
+  assert.equal("⚡".length, 1);
+  assert.equal(getVisualWidth("⚡"), 2);
+});
+
+test("clamps text to a visual width budget", () => {
+  assert.equal(clampVisualText("ACTION REQUIRED", 8), "ACTION …");
+  assert.equal(clampVisualText("⚡⚡", 3), "⚡…");
+});