@cueloop/client 0.1.0-alpha.9 → 0.1.0-alpha.90

package/src/__snapshots__/view-plan.regression.test.ts.snap

@@ -0,0 +1,100 @@
+// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
+
+exports[`view-plan regression harness (M0) blockRuns output is stable across the representative blocks 1`] = `
+[
+  {
+    "runs": [
+      {
+        "role": "plain",
+        "start": 0,
+        "text": "Heading with ",
+      },
+      {
+        "role": "strong",
+        "start": 15,
+        "text": "bold",
+      },
+    ],
+    "text": "Heading with **bold**",
+    "type": "same",
+  },
+  {
+    "runs": [
+      {
+        "role": "plain",
+        "start": 0,
+        "text": "A paragraph with ",
+      },
+      {
+        "role": "strong",
+        "start": 19,
+        "text": "strong",
+      },
+      {
+        "role": "plain",
+        "start": 27,
+        "text": ", ",
+      },
+      {
+        "role": "em",
+        "start": 30,
+        "text": "em",
+      },
+      {
+        "role": "plain",
+        "start": 33,
+        "text": ", ",
+      },
+      {
+        "role": "code",
+        "start": 36,
+        "text": "code",
+      },
+      {
+        "role": "plain",
+        "start": 41,
+        "text": ", ",
+      },
+      {
+        "role": "strike",
+        "start": 45,
+        "text": "strike",
+      },
+      {
+        "role": "plain",
+        "start": 53,
+        "text": " and a ",
+      },
+      {
+        "href": "https://example.com",
+        "role": "link",
+        "start": 61,
+        "text": "label",
+      },
+      {
+        "role": "plain",
+        "start": 88,
+        "text": ".",
+      },
+    ],
+    "text": "A paragraph with **strong**, *em*, \`code\`, ~~strike~~ and a [label](https://example.com).",
+    "type": "same",
+  },
+  {
+    "runs": [
+      {
+        "role": "plain",
+        "start": 0,
+        "text": "a list item with ",
+      },
+      {
+        "role": "em",
+        "start": 18,
+        "text": "emphasis",
+      },
+    ],
+    "text": "a list item with *emphasis*",
+    "type": "same",
+  },
+]
+`;

package/src/annotation-palette.ts

@@ -0,0 +1,62 @@
+/**
+ * The shared annotation palette: how a marked stretch, the caret cell, and a
+ * discussion card's accent edge paint, in every surface that hosts inline
+ * comments (the plan thread view and the diff sheet). One source, so a mark
+ * looks the same wherever it is drawn.
+ */
+
+import { createTextAttributes } from "@opentui/core";
+import type { Theme } from "./theme";
+
+export const UNDERLINE = createTextAttributes({ underline: true });
+export const CUT = createTextAttributes({ strikethrough: true, dim: true });
+export const BOLD = createTextAttributes({ bold: true });
+export const ITALIC = createTextAttributes({ italic: true });
+
+/** The marked-words treatment: a violet backdrop under an underline. */
+const MARK_BACKDROP_DARK = "#463852";
+const MARK_BACKDROP_LIGHT = "#e6ddf5";
+/** The discussion card's accent left edge. */
+const CARD_EDGE_DARK = "#ab7aca";
+const CARD_EDGE_LIGHT = "#8b5fd6";
+/** The caret cell: a visible cursor painted on the character under the caret. */
+const CARET_CELL_DARK = "#565b68";
+const CARET_CELL_LIGHT = "#b8bcc8";
+
+export interface AnnotationPalette {
+  markBackdrop: string;
+  cardEdge: string;
+  caretCell: string;
+}
+
+/** Dark tokens carry light text; use that to pick the palette variant. */
+export function annotationPaletteFor(tokens: Theme): AnnotationPalette {
+  const dark = Number.parseInt(tokens.text.slice(1, 3) || "e4", 16) > 128;
+
+  return dark
+    ? { markBackdrop: MARK_BACKDROP_DARK, cardEdge: CARD_EDGE_DARK, caretCell: CARET_CELL_DARK }
+    : {
+        markBackdrop: MARK_BACKDROP_LIGHT,
+        cardEdge: CARD_EDGE_LIGHT,
+        caretCell: CARET_CELL_LIGHT,
+      };
+}
+
+/** Focus cue: mix a hex color toward white, keeping its hue readable. */
+export function lighten(hex: string, amount = 0.25): string {
+  const channels = hex.match(/^#(..)(..)(..)$/);
+
+  if (!channels) return hex;
+  const lifted = channels
+    .slice(1)
+    .map((channel) => {
+      const value = Number.parseInt(channel, 16);
+
+      return Math.round(value + (255 - value) * amount)
+        .toString(16)
+        .padStart(2, "0");
+    })
+    .join("");
+
+  return `#${lifted}`;
+}

package/src/ansi-screen.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { ansiScreenToLines } from "./ansi-screen";
+
+describe("ansiScreenToLines", () => {
+  test("places text at the positioned cursor", () => {
+    const lines = ansiScreenToLines("\x1b[2;3Hhi", 10, 4);
+
+    expect(lines[0]).toBe("");
+    expect(lines[1]).toBe("  hi");
+    expect(lines[2]).toBe("");
+  });
+
+  test("clears the screen before repositioning", () => {
+    const lines = ansiScreenToLines("\x1b[1;1Hold\x1b[2J\x1b[1;1Hnew", 10, 2);
+
+    expect(lines[0]).toBe("new");
+  });
+
+  test("ignores colour, cursor-visibility, and clipboard sequences", () => {
+    const lines = ansiScreenToLines("\x1b[?25l\x1b[1;1H\x1b[32mgo\x1b]52;c;AA\x07", 10, 2);
+
+    expect(lines[0]).toBe("go");
+  });
+
+  test("clamps writes outside the grid instead of throwing", () => {
+    expect(() => ansiScreenToLines("\x1b[99;99Hx", 5, 3)).not.toThrow();
+  });
+});

package/src/ansi-screen.ts

@@ -0,0 +1,72 @@
+/** Interpret an absolute-positioned ANSI byte stream (cursor moves plus printed text) into a grid of rows. */
+
+const CSI = "\x1b[";
+
+export function ansiScreenToLines(ansi: string, cols: number, rows: number): string[] {
+  const grid: string[][] = Array.from({ length: rows }, () =>
+    Array.from({ length: cols }, () => " "),
+  );
+  let row = 0;
+  let column = 0;
+  let index = 0;
+
+  const put = (character: string): void => {
+    if (row >= 0 && row < rows && column >= 0 && column < cols) grid[row]![column] = character;
+    column += 1;
+  };
+
+  while (index < ansi.length) {
+    const character = ansi[index]!;
+
+    if (character === "\x1b") {
+      index = consumeEscape(ansi, index, (nextRow, nextColumn) => {
+        if (nextRow === "clear") {
+          for (const line of grid) line.fill(" ");
+          row = 0;
+          column = 0;
+        } else {
+          row = nextRow;
+          column = nextColumn;
+        }
+      });
+      continue;
+    }
+    if (character === "\n") {
+      row += 1;
+      column = 0;
+    } else if (character === "\r") {
+      column = 0;
+    } else {
+      put(character);
+    }
+    index += 1;
+  }
+
+  return grid.map((line) => line.join("").replace(/\s+$/, ""));
+}
+
+type EscapeEffect = (row: number | "clear", column: number) => void;
+
+function consumeEscape(ansi: string, start: number, apply: EscapeEffect): number {
+  if (ansi[start + 1] === "]") {
+    const bell = ansi.indexOf("\x07", start);
+
+    return bell === -1 ? ansi.length : bell + 1;
+  }
+  if (ansi.slice(start, start + CSI.length) !== CSI) return start + 1;
+  let index = start + CSI.length;
+
+  while (index < ansi.length && !/[A-Za-z]/.test(ansi[index]!)) index += 1;
+  const final = ansi[index];
+  const parameters = ansi.slice(start + CSI.length, index);
+
+  if (final === "H" || final === "f") {
+    const [rowParameter = "1", columnParameter = "1"] = parameters.split(";");
+
+    apply(Math.max(0, Number(rowParameter) - 1), Math.max(0, Number(columnParameter) - 1));
+  } else if (final === "J" && parameters === "2") {
+    apply("clear", 0);
+  }
+
+  return index + 1;
+}

package/src/app-key-state.ts

@@ -0,0 +1,61 @@
+import type { Thread } from "@cueloop/schema";
+import type { Mode } from "./intent-dispatch";
+import type { KeyState } from "./keymap";
+import type { DisplayBlock } from "./view-plan";
+import type { DiffRow } from "./view-diff";
+import type { WalkFile } from "./walk";
+
+export function buildKeyState(params: {
+  keys: Record<string, string[]>;
+  observer: boolean;
+  isOwner: boolean;
+  overlay: KeyState["overlay"];
+  session: Thread | null;
+  isDiff: boolean;
+  mode: Mode;
+  resolved: boolean;
+  inbox: Thread[] | null;
+  focusedAnnotationId: string | undefined;
+  walk: { index: number } | null;
+  walkFileList: WalkFile[];
+  rows: DiffRow[];
+  cursor: number;
+  display: DisplayBlock[];
+}): KeyState {
+  const {
+    keys,
+    observer,
+    isOwner,
+    overlay,
+    session,
+    isDiff,
+    mode,
+    resolved,
+    inbox,
+    focusedAnnotationId,
+    walk,
+    walkFileList,
+    rows,
+    cursor,
+    display,
+  } = params;
+
+  return {
+    keys,
+    readOnly: observer,
+    canEditPlan: isOwner,
+    canSubmitMessage: isOwner,
+    canShare: isOwner,
+    overlay,
+    view: !session ? "inbox" : isDiff ? "diff" : "plan",
+    spanMode: mode.type === "span",
+    resolved,
+    hasInboxItems: !!inbox?.length,
+    annotationCount: session?.annotations.length ?? 0,
+    hasFocusedAnnotation: focusedAnnotationId !== undefined,
+    walkAtEnd: walk !== null && walk.index >= walkFileList.length,
+    cursorAnnotatable: isDiff
+      ? rows[cursor] !== undefined && rows[cursor]!.kind !== "file" && rows[cursor]!.kind !== "hunk"
+      : !!display[cursor]?.work,
+  };
+}