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

package/src/slash-palette.ts

@@ -0,0 +1,129 @@
+/**
+ * The "/" quick-action palette behind a composer: the skill list a leading
+ * slash opens, its prefix > substring > subsequence filter, and the inline
+ * "/word" completion offered mid-sentence. Pure; the surfaces render it.
+ */
+
+import { quickActionBody, type QuickAction } from "./config";
+
+export interface SlashItem {
+  name: string;
+  description: string;
+  body: string;
+}
+
+export function slashItemsFrom(quickActions: QuickAction[]): SlashItem[] {
+  return quickActions.map((action) => ({
+    name: action.prompt
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, ""),
+    description: action.metadata ?? action.prompt,
+    body: quickActionBody(action),
+  }));
+}
+
+const WORD_BOUNDARY = /[\s\-_./:]/;
+
+/** Order-preserving subsequence score, or null when a query character is missing; higher is better. */
+export function scoreMatch(name: string, query: string): number | null {
+  if (query.length === 0) return 0;
+  const lowerName = name.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+
+  if (lowerName === lowerQuery) return 1000;
+  if (lowerName.startsWith(lowerQuery)) return 500 - name.length;
+  let score = 0;
+  let cursor = 0;
+  let run = 0;
+
+  for (const character of lowerQuery) {
+    const found = lowerName.indexOf(character, cursor);
+
+    if (found === -1) return null;
+    run = found === cursor ? run + 1 : 0;
+    score += found === cursor ? 5 + run : 1;
+    if (found === 0 || WORD_BOUNDARY.test(lowerName[found - 1]!)) score += 10;
+    score -= found - cursor;
+    cursor = found + 1;
+  }
+
+  return score;
+}
+
+export function slashFilter(items: SlashItem[], query: string): SlashItem[] {
+  if (query.length === 0) return items;
+  const scored: Array<{ item: SlashItem; score: number }> = [];
+
+  for (const item of items) {
+    const score = scoreMatch(item.name, query);
+
+    if (score !== null) scored.push({ item, score });
+  }
+
+  return scored.toSorted((left, right) => right.score - left.score).map((entry) => entry.item);
+}
+
+// a skill or action name: the grammar loadSkills and slashItemsFrom can produce, so a "/name"
+// token closes only on whitespace or another slash, never inside a valid underscore-or-hyphen name
+const SLASH_TOKEN = /(?:^|\s)(\/[a-zA-Z0-9_-]*)$/;
+
+/**
+ * The "/word" token the caret is writing right now: the run from the last
+ * whitespace up to the caret, at the start of the draft or after it. Null once a
+ * space closes the token, so each new "/" reopens the palette and skills chain.
+ * Caret-aware, so editing an earlier "/name" targets it, not a trailing token.
+ */
+export function activeSlashToken(text: string, caret: number): string | null {
+  const head = text.slice(0, Math.max(0, Math.min(caret, text.length)));
+  const match = SLASH_TOKEN.exec(head);
+
+  return match ? match[1]! : null;
+}
+
+/** True while the whole draft is just a "/query" - the palette owns it, so a blur discards it. */
+export function isStandaloneSlashQuery(text: string): boolean {
+  return /^\/\S*$/.test(text.trim());
+}
+
+export function insertSlashItem(text: string, caret: number, itemName: string) {
+  const token = activeSlashToken(text, caret) ?? "";
+  const cut = caret - token.length;
+  const insertion = `/${itemName} `;
+
+  return {
+    text: text.slice(0, cut) + insertion + text.slice(caret),
+    caret: cut + insertion.length,
+  };
+}
+
+/**
+ * The character ranges of every completed "/name" in the draft that names a real
+ * action or skill, so a surface can paint the references. A half-typed "/na" is
+ * not a reference yet, so it stays unpainted until the palette completes it.
+ */
+export function skillReferenceRanges(
+  text: string,
+  names: ReadonlySet<string>,
+): Array<{ start: number; end: number }> {
+  const ranges: Array<{ start: number; end: number }> = [];
+  const pattern = /(?:^|\s)(\/[a-zA-Z0-9_-]+)/g;
+
+  for (let match = pattern.exec(text); match !== null; match = pattern.exec(text)) {
+    const token = match[1]!;
+
+    if (!names.has(token.slice(1))) continue;
+    const start = match.index + match[0].length - token.length;
+
+    ranges.push({ start, end: start + token.length });
+  }
+
+  return ranges;
+}
+
+/** Quick actions and user skills in one palette; a quick action wins a name collision (it expands). */
+export function mergeSlashItems(actions: SlashItem[], skills: SlashItem[]): SlashItem[] {
+  const taken = new Set(actions.map((action) => action.name));
+
+  return [...actions, ...skills.filter((skill) => !taken.has(skill.name))];
+}

package/src/split-diff.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, test } from "bun:test";
+import { diffRows } from "./view-diff";
+import { splitDiffRows, splitRowOffsets, type SplitRow } from "./split-diff";
+
+const PATCH = `diff --git a/greet.ts b/greet.ts
+--- a/greet.ts
++++ b/greet.ts
+@@ -1,4 +1,4 @@
+ const name = "world";
+-console.log("hi " + name);
+-console.log("done");
++console.log("hello " + name);
++console.log("finished");
+ export {};
+`;
+
+function pairs(rows: SplitRow[]): SplitRow[] {
+  return rows.filter((row) => row.kind === "pair");
+}
+
+describe("splitDiffRows", () => {
+  test("carries the file and hunk headers through unchanged", () => {
+    // Act
+    const split = splitDiffRows(diffRows(PATCH));
+
+    // Assert
+    expect(split[0]).toMatchObject({ kind: "file", file: "greet.ts", text: "greet.ts" });
+    expect(split[1]?.kind).toBe("hunk");
+  });
+
+  test("a context line sits on both sides with its own line numbers", () => {
+    // Act
+    const first = pairs(splitDiffRows(diffRows(PATCH)))[0]!;
+
+    // Assert
+    expect(first.left).toMatchObject({ kind: "ctx", lineNumber: 1 });
+    expect(first.right).toMatchObject({ kind: "ctx", lineNumber: 1 });
+    expect(first.left?.text).toBe(first.right?.text);
+  });
+
+  test("a balanced change block pairs each deletion against an addition", () => {
+    // Act - the two deletions zip against the two additions, one per row
+    const changed = pairs(splitDiffRows(diffRows(PATCH))).filter(
+      (row) => row.left?.kind === "del" || row.right?.kind === "add",
+    );
+
+    // Assert
+    expect(changed).toHaveLength(2);
+    expect(changed[0]).toMatchObject({
+      left: { kind: "del", lineNumber: 2 },
+      right: { kind: "add", lineNumber: 2 },
+    });
+    expect(changed[1]).toMatchObject({
+      left: { kind: "del", lineNumber: 3 },
+      right: { kind: "add", lineNumber: 3 },
+    });
+  });
+
+  test("an unbalanced block blank-fills the shorter side", () => {
+    // Arrange - one deletion, three additions
+    const patch = `diff --git a/x.ts b/x.ts
+--- a/x.ts
++++ b/x.ts
+@@ -1,2 +1,4 @@
+ keep;
+-old;
++new1;
++new2;
++new3;
+`;
+
+    // Act
+    const changed = pairs(splitDiffRows(diffRows(patch))).filter(
+      (row) => row.left?.kind === "del" || row.right?.kind === "add",
+    );
+
+    // Assert - three rows tall, only the first has a left deletion
+    expect(changed).toHaveLength(3);
+    expect(changed[0]?.left?.kind).toBe("del");
+    expect(changed[1]?.left).toBeUndefined();
+    expect(changed[2]?.left).toBeUndefined();
+    expect(changed.map((row) => row.right?.text.trim())).toEqual(["new1;", "new2;", "new3;"]);
+  });
+
+  test("each side keeps its originating unified row for anchoring", () => {
+    // Act
+    const base = diffRows(PATCH);
+    const changed = pairs(splitDiffRows(base)).find((row) => row.right?.kind === "add")!;
+
+    // Assert - the split line points back at a row from the base list
+    expect(base[changed.right!.rowIndex]).toBe(changed.right!.row);
+  });
+});
+
+describe("splitRowOffsets", () => {
+  test("maps both sides of a pair to the same y and steps a file band by three", () => {
+    // Arrange
+    const base = diffRows(PATCH);
+    const split = splitDiffRows(base);
+
+    // Act
+    const offsets = splitRowOffsets(split);
+
+    // Assert - the file band is three rows and the hunk one, so the first context pair sits at y 4
+    const firstContext = split.find((row) => row.kind === "pair" && row.left?.kind === "ctx")!;
+
+    expect(offsets.get(firstContext.left!.rowIndex)).toBe(4);
+    expect(offsets.get(firstContext.right!.rowIndex)).toBe(4);
+  });
+});

package/src/split-diff.ts

@@ -0,0 +1,149 @@
+/**
+ * Side-by-side diff projection: fold the unified DiffRow list into paired rows,
+ * old on the left and new on the right. A context line sits on both sides; a
+ * change block zips its deletions against its additions to the taller side, with
+ * a blank filler where one side runs out. Each side keeps its originating unified
+ * row, so the cursor, anchors, and curation keep working through the base rows.
+ */
+
+import type { DiffRow } from "./view-diff";
+
+/** One code line on one side of the split, carrying its originating unified row. */
+export interface SplitLine {
+  /** The unified diff row this side renders; the anchor and curation target. */
+  row: DiffRow;
+  /** Index of the originating row in the base list; the cursor and curation index. */
+  rowIndex: number;
+  kind: "ctx" | "del" | "add";
+  text: string;
+  /** Old line number for the left column, new line number for the right column. */
+  lineNumber?: number;
+}
+
+/** A rendered split row: a file band, a hunk header, or an old|new line pair. */
+export interface SplitRow {
+  kind: "file" | "hunk" | "pair";
+  file: string;
+  /** Header text for file and hunk rows. */
+  text?: string;
+  /** Index of the header in the base list, for file and hunk rows. */
+  rowIndex?: number;
+  /** Old side: a context or deletion line, or absent (blank filler). */
+  left?: SplitLine;
+  /** New side: a context or addition line, or absent (blank filler). */
+  right?: SplitLine;
+}
+
+/** A base row paired with its index in the base list. */
+interface IndexedRow {
+  row: DiffRow;
+  index: number;
+}
+
+function contextLine({ row, index }: IndexedRow, side: "left" | "right"): SplitLine {
+  return {
+    row,
+    rowIndex: index,
+    kind: "ctx",
+    text: row.text,
+    lineNumber: side === "left" ? row.oldLine : row.newLine,
+  };
+}
+
+function deletionLine({ row, index }: IndexedRow): SplitLine {
+  return { row, rowIndex: index, kind: "del", text: row.text, lineNumber: row.oldLine };
+}
+
+function additionLine({ row, index }: IndexedRow): SplitLine {
+  return { row, rowIndex: index, kind: "add", text: row.text, lineNumber: row.newLine };
+}
+
+/** Zip a change block's deletions against its additions, blank-filling the shorter side. */
+function zipChangeBlock(
+  deletions: IndexedRow[],
+  additions: IndexedRow[],
+  file: string,
+): SplitRow[] {
+  const pairs: SplitRow[] = [];
+  const height = Math.max(deletions.length, additions.length);
+
+  for (let index = 0; index < height; index++) {
+    const del = deletions[index];
+    const add = additions[index];
+
+    pairs.push({
+      kind: "pair",
+      file,
+      left: del ? deletionLine(del) : undefined,
+      right: add ? additionLine(add) : undefined,
+    });
+  }
+
+  return pairs;
+}
+
+/** Project unified diff rows into side-by-side split rows. */
+export function splitDiffRows(rows: DiffRow[]): SplitRow[] {
+  const split: SplitRow[] = [];
+  let pendingDeletions: IndexedRow[] = [];
+  let pendingAdditions: IndexedRow[] = [];
+  let blockFile = "";
+
+  const flushChangeBlock = (): void => {
+    if (pendingDeletions.length === 0 && pendingAdditions.length === 0) return;
+    split.push(...zipChangeBlock(pendingDeletions, pendingAdditions, blockFile));
+    pendingDeletions = [];
+    pendingAdditions = [];
+  };
+
+  rows.forEach((row, index) => {
+    if (row.kind === "add") {
+      blockFile = row.file;
+      pendingAdditions.push({ row, index });
+      return;
+    }
+    if (row.kind === "del") {
+      blockFile = row.file;
+      pendingDeletions.push({ row, index });
+      return;
+    }
+    // any non-change row closes the current change block before it renders
+    flushChangeBlock();
+    if (row.kind === "file" || row.kind === "hunk") {
+      split.push({ kind: row.kind, file: row.file, text: row.text, rowIndex: index });
+    } else
+      split.push({
+        kind: "pair",
+        file: row.file,
+        left: contextLine({ row, index }, "left"),
+        right: contextLine({ row, index }, "right"),
+      });
+  });
+  flushChangeBlock();
+
+  return split;
+}
+
+/**
+ * Visual y of each base row index in the split layout, so the cursor scrolls into
+ * view. A file band spans three rows (rule, name, rule), a hunk one, a pair one; a
+ * pair's two sides share the row, so both base indices map to the same y.
+ */
+export function splitRowOffsets(splitRows: SplitRow[]): Map<number, number> {
+  const offsets = new Map<number, number>();
+  let contentY = 0;
+
+  for (const row of splitRows) {
+    if (row.kind === "file") {
+      contentY += 3;
+    } else if (row.kind === "hunk") {
+      contentY += 1;
+    } else {
+      if (row.left) offsets.set(row.left.rowIndex, contentY);
+      if (row.right) offsets.set(row.right.rowIndex, contentY);
+      contentY += 1;
+    }
+  }
+
+  return offsets;
+}

package/src/test-support.test.ts

@@ -0,0 +1,264 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createElement, type ReactElement } from "react";
+import type { KeyEvent, MouseEvent } from "@opentui/core";
+import type { TestRendererSetup } from "@opentui/core/testing";
+import { useKeyboard } from "@opentui/react";
+import { testRender } from "@opentui/react/test-utils";
+import { loadConfig } from "./config";
+import {
+  clickText,
+  dragText,
+  frameRow,
+  isolateUserConfig,
+  locateText,
+  locateTextInFrame,
+  pressKey,
+  waitForText,
+  type FrameLocation,
+} from "./test-support";
+
+describe("isolateUserConfig", () => {
+  test("loadConfig sees defaults while isolated and the env is restored after", () => {
+    // Arrange
+    const home = mkdtempSync(join(tmpdir(), "cueloop-isolate-"));
+    const userConfigPath = join(home, "config.toml");
+
+    writeFileSync(userConfigPath, "[ui]\nauto_close = 5\n");
+    const priorEnv = process.env.CUELOOP_CONFIG;
+
+    process.env.CUELOOP_CONFIG = userConfigPath;
+
+    try {
+      // Act
+      const restoreUserConfig = isolateUserConfig(home);
+      const isolated = loadConfig({ repoRoot: home });
+
+      restoreUserConfig();
+      const restored = loadConfig({ repoRoot: home });
+
+      // Assert
+      expect(isolated.ui.autoClose).toBe("off");
+      expect(process.env.CUELOOP_CONFIG).toBe(userConfigPath);
+      expect(restored.ui.autoClose).toBe(5);
+    } finally {
+      if (priorEnv === undefined) delete process.env.CUELOOP_CONFIG;
+      else process.env.CUELOOP_CONFIG = priorEnv;
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
+
+  test("restore removes the variable when nothing was set before", () => {
+    // Arrange
+    const home = mkdtempSync(join(tmpdir(), "cueloop-isolate-"));
+    const priorEnv = process.env.CUELOOP_CONFIG;
+
+    delete process.env.CUELOOP_CONFIG;
+
+    try {
+      // Act
+      const restoreUserConfig = isolateUserConfig(home);
+      const pointedAt = process.env.CUELOOP_CONFIG ?? "";
+
+      restoreUserConfig();
+
+      // Assert
+      expect(pointedAt).toBe(join(home, "no-config.toml"));
+      expect(process.env.CUELOOP_CONFIG).toBeUndefined();
+    } finally {
+      if (priorEnv !== undefined) process.env.CUELOOP_CONFIG = priorEnv;
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
+});
+
+interface RecordedKey {
+  name: string;
+  ctrl: boolean;
+  shift: boolean;
+  meta: boolean;
+}
+
+interface RecordedMouseEvent {
+  type: "down" | "up";
+  x: number;
+  y: number;
+}
+
+interface FixtureLog {
+  keys: RecordedKey[];
+  mouseEvents: RecordedMouseEvent[];
+  pressZoneClicks: number[];
+}
+
+/**
+ * A minimal interaction surface: one keyboard recorder, a root box recording
+ * down/up coordinates, and stacked text rows at known positions.
+ */
+function InteractionFixture(properties: { log: FixtureLog }): ReactElement {
+  const { log } = properties;
+
+  useKeyboard((key: KeyEvent) => {
+    log.keys.push({ name: key.name, ctrl: key.ctrl, shift: key.shift, meta: key.meta });
+  });
+
+  return createElement(
+    "box",
+    {
+      width: "100%",
+      height: "100%",
+      flexDirection: "column",
+      onMouseDown: (event: MouseEvent) => {
+        log.mouseEvents.push({ type: "down", x: event.x, y: event.y });
+      },
+      onMouseUp: (event: MouseEvent) => {
+        log.mouseEvents.push({ type: "up", x: event.x, y: event.y });
+      },
+    },
+    createElement("text", { content: "header line" }),
+    createElement("text", { content: "   shifted needle" }),
+    createElement("text", { content: "  drag from here" }),
+    createElement("text", { content: "     drop to here" }),
+    createElement("text", {
+      content: "press zone",
+      onMouseDown: (event: MouseEvent) => {
+        log.pressZoneClicks.push(event.x);
+      },
+    }),
+  );
+}
+
+async function renderFixture(): Promise<{ setup: TestRendererSetup; log: FixtureLog }> {
+  const log: FixtureLog = { keys: [], mouseEvents: [], pressZoneClicks: [] };
+  const setup = await testRender(createElement(InteractionFixture, { log }), {
+    width: 40,
+    height: 8,
+  });
+
+  await waitForText(setup, "press zone");
+
+  return { setup, log };
+}
+
+describe("pressKey", () => {
+  test("a ctrl+letter chord reaches the keyboard handler with ctrl set", async () => {
+    // Arrange
+    const { setup, log } = await renderFixture();
+
+    // Act
+    await pressKey(setup, "o", { ctrl: true });
+
+    // Assert
+    expect(log.keys).toEqual([{ name: "o", ctrl: true, shift: false, meta: false }]);
+  });
+
+  test("a named key with a modifier arrives as the modified key", async () => {
+    // Arrange
+    const { setup, log } = await renderFixture();
+
+    // Act
+    await pressKey(setup, "ARROW_RIGHT", { shift: true });
+
+    // Assert
+    expect(log.keys).toEqual([{ name: "right", ctrl: false, shift: true, meta: false }]);
+  });
+});
+
+describe("locateText", () => {
+  test("returns the 0-based row and start column of the first occurrence", async () => {
+    // Arrange
+    const { setup } = await renderFixture();
+
+    // Act
+    const located = locateText(setup, "shifted needle");
+
+    // Assert
+    expect(located).toEqual({ row: 1, column: 3 });
+  });
+
+  test("a miss throws with the needle and the full frame in the message", async () => {
+    // Arrange
+    const { setup } = await renderFixture();
+
+    // Act
+    const locateMissing = (): FrameLocation => locateText(setup, "absent needle");
+
+    // Assert
+    expect(locateMissing).toThrow('"absent needle"');
+    expect(locateMissing).toThrow("header line");
+  });
+});
+
+describe("frameRow", () => {
+  test("returns rows that reflect the vertical layout", async () => {
+    // Arrange
+    const { setup } = await renderFixture();
+
+    // Act / Assert
+    expect(frameRow(setup, "header line")).toBe(0);
+    expect(frameRow(setup, "drop to here")).toBe(3);
+    expect(frameRow(setup, "press zone")).toBe(4);
+  });
+});
+
+describe("clickText", () => {
+  test("lands the click on the element rendering the needle", async () => {
+    // Arrange
+    const { setup, log } = await renderFixture();
+
+    // Act
+    await clickText(setup, "press zone");
+
+    // Assert
+    expect(log.pressZoneClicks).toEqual([0]);
+  });
+
+  test("charOffset shifts the click within the needle", async () => {
+    // Arrange
+    const { setup, log } = await renderFixture();
+
+    // Act
+    await clickText(setup, "press zone", 6);
+
+    // Assert
+    expect(log.pressZoneClicks).toEqual([6]);
+  });
+});
+
+describe("dragText", () => {
+  test("delivers the down at the from-text and the up at the to-text", async () => {
+    // Arrange
+    const { setup, log } = await renderFixture();
+
+    // Act
+    await dragText(setup, "drag from here", "drop to here");
+
+    // Assert
+    expect(log.mouseEvents).toContainEqual({ type: "down", x: 2, y: 2 });
+    expect(log.mouseEvents).toContainEqual({ type: "up", x: 5, y: 3 });
+  });
+
+  test("an end offset lands the up that many characters past the to-text", async () => {
+    // Arrange
+    const { setup, log } = await renderFixture();
+
+    // Act
+    await dragText(setup, "drag from here", "drop to here", 4);
+
+    // Assert
+    expect(log.mouseEvents).toContainEqual({ type: "up", x: 9, y: 3 });
+  });
+});
+
+describe("locateTextInFrame", () => {
+  test("finds the 0-based row and column of the first match, null when absent", () => {
+    // Arrange
+    const frame = "header\n  ● draft here\nfooter";
+
+    // Act + Assert
+    expect(locateTextInFrame(frame, "draft")).toEqual({ row: 1, column: 4 });
+    expect(locateTextInFrame(frame, "missing")).toBeNull();
+  });
+});