@cueloop/client 0.1.0-alpha.7 → 0.1.0-alpha.71

package/src/theme.ts

@@ -1,12 +1,12 @@
 /**
- * Semantic theme tokens (#22). Values carry over from the design-system
+ * Semantic theme tokens. Values carry over from the design-system
  * prototypes (tokens.css). One built-in dark theme for now; the theme
  * registry (palette-derived themes, terminal theme, user overrides) layers
  * on top of these slots without touching consumers.
  */
 
 export interface Theme {
-  bg: string;
+  background: string;
   panel: string;
   elevated: string;
   border: string;
@@ -18,29 +18,94 @@ export interface Theme {
   green: string;
   red: string;
   blue: string;
-  cursorBg: string;
-  markCommentBg: string;
-  markSuggestionBg: string;
-  insFg: string;
-  delFg: string;
+  cursorBackground: string;
+  markCommentBackground: string;
+  insertedForeground: string;
+  deletedForeground: string;
+  /** The band behind a whole added line, and the stronger tint under its intra-line changed words. */
+  insertedBackground: string;
+  insertedEmphasisBackground: string;
+  /** The band behind a whole removed line, and the stronger tint under its intra-line changed words. */
+  deletedBackground: string;
+  deletedEmphasisBackground: string;
+  /** Layer behind centered dialogs; transparent keeps the session visible. */
+  backdrop: string;
+}
+
+/**
+ * The dimmed variant behind the walk wizard: every reading color drops to
+ * the dim token so the file list stays legible context, not competition.
+ * Layout tokens (backgrounds, cursor) keep their values.
+ */
+export function dimmedTheme(theme: Theme): Theme {
+  return {
+    ...theme,
+    text: theme.textDim,
+    textMuted: theme.textDim,
+    accent: theme.textDim,
+    green: theme.textDim,
+    red: theme.textDim,
+    blue: theme.textDim,
+    insertedForeground: theme.textDim,
+    deletedForeground: theme.textDim,
+    insertedBackground: theme.panel,
+    insertedEmphasisBackground: theme.elevated,
+    deletedBackground: theme.panel,
+    deletedEmphasisBackground: theme.elevated,
+  };
 }
 
 export const DARK: Theme = {
-  bg: "#1f1f29",
-  panel: "#1a1a23",
+  /* Unpainted so the terminal background shows through; override in [theme]. */
+  background: "transparent",
+  panel: "transparent",
   elevated: "#23232f",
   border: "#3a3a4a",
   text: "#e4e6ec",
   textMuted: "#b1b6c4",
   textDim: "#6b7280",
-  accent: "#f5a3a3",
-  accentInk: "#2a1416",
+  accent: "#cba6f7",
+  accentInk: "#17171a",
   green: "#62d96b",
-  red: "#ff6b6b",
-  blue: "#84a6e8",
-  cursorBg: "#33262a",
-  markCommentBg: "#3d2a2e",
-  markSuggestionBg: "#20351f",
-  insFg: "#62d96b",
-  delFg: "#ff6b6b",
-}
+  red: "#f08080",
+  blue: "#a9c8f5",
+  cursorBackground: "#33262a",
+  markCommentBackground: "#3d2a2e",
+  insertedForeground: "#62d96b",
+  deletedForeground: "#ff6b6b",
+  insertedBackground: "#16321d",
+  insertedEmphasisBackground: "#245c30",
+  deletedBackground: "#341c1f",
+  deletedEmphasisBackground: "#5a2a2e",
+  backdrop: "transparent",
+};
+
+/**
+ * The branded transparent theme for a LIGHT terminal: same unpainted
+ * background, but every reading color darkens so text is legible on a white
+ * terminal instead of light-on-light. Chosen when the terminal reports a light
+ * background; the dark variant above is the default and the fallback.
+ */
+export const LIGHT: Theme = {
+  background: "transparent",
+  panel: "transparent",
+  elevated: "#ececf2",
+  border: "#c7c7d2",
+  text: "#1c1d24",
+  textMuted: "#4b5162",
+  textDim: "#868c9c",
+  accent: "#5b3ea6",
+  accentInk: "#fbfbfa",
+  green: "#2f8a3e",
+  red: "#c0392b",
+  blue: "#2f6fb0",
+  cursorBackground: "#e6e2ea",
+  markCommentBackground: "#f2e2e8",
+  insertedForeground: "#2f8a3e",
+  deletedForeground: "#c0392b",
+  insertedBackground: "#d8f5dd",
+  insertedEmphasisBackground: "#a9e6b6",
+  deletedBackground: "#fbdcdc",
+  deletedEmphasisBackground: "#f5b7b7",
+  backdrop: "transparent",
+};

package/src/thread-chords.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, test } from "bun:test";
+import { resolveThreadChord } from "./thread-chords";
+
+const owner = { composing: false, isOwner: true, resolved: false, treeActive: false };
+
+describe("resolveThreadChord", () => {
+  test("ctrl+enter opens the submit overlay for an owner with an open review", () => {
+    // Assert: the terminal-safe chord and the cmd forms all submit
+    expect(resolveThreadChord({ name: "return", ctrl: true }, owner)).toEqual({
+      type: "openSubmit",
+    });
+    expect(resolveThreadChord({ name: "return", super: true }, owner)).toEqual({
+      type: "openSubmit",
+    });
+    expect(resolveThreadChord({ name: "enter", meta: true }, owner)).toEqual({
+      type: "openSubmit",
+    });
+  });
+
+  test("session chords map to their intents", () => {
+    // Assert
+    expect(resolveThreadChord({ name: "e", ctrl: true }, owner)).toEqual({ type: "edit" });
+    expect(resolveThreadChord({ name: "s", ctrl: true }, owner)).toEqual({ type: "share" });
+  });
+
+  test("in a diff, option chords act on the caret's row and file; the rest still reach the rail", () => {
+    // Arrange
+    const diff = { ...owner, isDiff: true };
+
+    // Assert - the code-row primitives
+    expect(resolveThreadChord({ name: "x", meta: true }, diff)).toEqual({ type: "rejectChange" });
+    expect(resolveThreadChord({ name: "X", meta: true }, diff)).toEqual({ type: "rejectHunk" });
+    expect(resolveThreadChord({ name: "u", meta: true }, diff)).toEqual({
+      type: "restoreCuration",
+    });
+    expect(resolveThreadChord({ name: "c", meta: true }, diff)).toEqual({ type: "foldFile" });
+    expect(resolveThreadChord({ name: "d", meta: true }, diff)).toEqual({ type: "toggleDiffView" });
+    expect(resolveThreadChord({ name: "k", meta: true }, diff)).toEqual({ type: "walkStart" });
+    // the rail letters are untouched
+    expect(resolveThreadChord({ name: "n", meta: true }, diff)).toEqual({ type: "nextAnnotation" });
+    // rejecting is the owner's, and closed once resolved
+    expect(resolveThreadChord({ name: "x", meta: true }, { ...diff, isOwner: false })).toEqual({
+      type: "status",
+      message: "observer - read-only",
+    });
+    expect(resolveThreadChord({ name: "k", meta: true }, { ...diff, resolved: true })).toEqual({
+      type: "status",
+      message: "review submitted - read-only",
+    });
+  });
+
+  test("option chords drive the rail and curation with the plan sheet's letters", () => {
+    // Assert
+    expect(resolveThreadChord({ name: "n", meta: true }, owner)).toEqual({
+      type: "nextAnnotation",
+    });
+    expect(resolveThreadChord({ name: "p", meta: true }, owner)).toEqual({
+      type: "prevAnnotation",
+    });
+    expect(resolveThreadChord({ name: "e", meta: true }, owner)).toEqual({ type: "editCard" });
+    expect(resolveThreadChord({ name: "backspace", meta: true }, owner)).toEqual({
+      type: "removeAnnotation",
+    });
+    expect(resolveThreadChord({ name: "r", meta: true }, owner)).toEqual({ type: "openRename" });
+    expect(resolveThreadChord({ name: "x", meta: true }, owner)).toEqual({ type: "cut" });
+    expect(resolveThreadChord({ name: "u", meta: true }, owner)).toEqual({
+      type: "restoreCuration",
+    });
+    expect(resolveThreadChord({ name: "x", meta: true }, { ...owner, isOwner: false })).toEqual({
+      type: "status",
+      message: "observer - read-only",
+    });
+  });
+
+  test("an open composer swallows every chord, so typing is never hijacked", () => {
+    // Assert
+    expect(
+      resolveThreadChord({ name: "return", ctrl: true }, { ...owner, composing: true }),
+    ).toBeNull();
+    expect(resolveThreadChord({ name: "s", ctrl: true }, { ...owner, composing: true })).toBeNull();
+  });
+
+  test("plain keys and unbound chords belong to the document grammar", () => {
+    // Assert
+    expect(resolveThreadChord({ name: "return" }, owner)).toBeNull();
+    expect(resolveThreadChord({ name: "s" }, owner)).toBeNull();
+    expect(resolveThreadChord({ name: "x", ctrl: true }, owner)).toBeNull();
+  });
+
+  test("a collaborator is told a primitive is read-only, and a resolved review cannot be resubmitted", () => {
+    // Assert
+    const collaborator = { ...owner, isOwner: false };
+    const readOnly = { type: "status" as const, message: "observer - read-only" };
+
+    expect(resolveThreadChord({ name: "return", ctrl: true }, collaborator)).toEqual(readOnly);
+    expect(resolveThreadChord({ name: "e", ctrl: true }, collaborator)).toEqual(readOnly);
+    expect(resolveThreadChord({ name: "s", ctrl: true }, collaborator)).toEqual(readOnly);
+    expect(
+      resolveThreadChord({ name: "return", ctrl: true }, { ...owner, resolved: true }),
+    ).toBeNull();
+  });
+
+  test("a resolved review refuses every change and says so; renaming an author stays open", () => {
+    // Arrange
+    const resolved = { ...owner, resolved: true };
+    const submitted = { type: "status" as const, message: "review submitted - read-only" };
+
+    // Assert
+    expect(resolveThreadChord({ name: "e", ctrl: true }, resolved)).toEqual(submitted);
+    expect(resolveThreadChord({ name: "e", meta: true }, resolved)).toEqual(submitted);
+    expect(resolveThreadChord({ name: "backspace", meta: true }, resolved)).toEqual(submitted);
+    expect(resolveThreadChord({ name: "x", meta: true }, resolved)).toEqual(submitted);
+    expect(resolveThreadChord({ name: "u", meta: true }, resolved)).toEqual(submitted);
+    expect(resolveThreadChord({ name: "r", meta: true }, resolved)).toEqual({ type: "openRename" });
+    expect(resolveThreadChord({ name: "s", ctrl: true }, resolved)).toEqual({ type: "share" });
+  });
+
+  test("the tree chords: toggle, move on the Tree tab, go, branch, label, fork, hand off", () => {
+    // Arrange
+    const onTree = { ...owner, treeActive: true };
+    const readOnly = { type: "status" as const, message: "observer - read-only" };
+    const submitted = { type: "status" as const, message: "review submitted - read-only" };
+
+    // Assert: next / previous follow the tab that shows
+    expect(resolveThreadChord({ name: "t", meta: true }, owner)).toEqual({ type: "toggleTree" });
+    expect(resolveThreadChord({ name: "n", meta: true }, onTree)).toEqual({
+      type: "treeMove",
+      direction: 1,
+    });
+    expect(resolveThreadChord({ name: "p", meta: true }, onTree)).toEqual({
+      type: "treeMove",
+      direction: -1,
+    });
+    expect(resolveThreadChord({ name: "n", meta: true }, owner)).toEqual({
+      type: "nextAnnotation",
+    });
+    expect(resolveThreadChord({ name: "g", meta: true }, owner)).toEqual({ type: "treeGo" });
+    expect(resolveThreadChord({ name: "b", meta: true }, owner)).toEqual({ type: "treeBranch" });
+    expect(resolveThreadChord({ name: "l", meta: true }, owner)).toEqual({ type: "treeLabel" });
+    expect(resolveThreadChord({ name: "f", meta: true }, owner)).toEqual({ type: "treeFork" });
+    expect(resolveThreadChord({ name: "h", meta: true }, owner)).toEqual({ type: "treeForkShare" });
+    // moving the tree is the owner's; a fork is open after a verdict, a move is not
+    expect(resolveThreadChord({ name: "g", meta: true }, { ...owner, isOwner: false })).toEqual(
+      readOnly,
+    );
+    expect(resolveThreadChord({ name: "f", meta: true }, { ...owner, isOwner: false })).toEqual(
+      readOnly,
+    );
+    expect(resolveThreadChord({ name: "b", meta: true }, { ...owner, resolved: true })).toEqual(
+      submitted,
+    );
+    expect(resolveThreadChord({ name: "f", meta: true }, { ...owner, resolved: true })).toEqual({
+      type: "treeFork",
+    });
+    expect(resolveThreadChord({ name: "t", meta: true }, { ...owner, isOwner: false })).toEqual({
+      type: "toggleTree",
+    });
+  });
+
+  test("an observer cannot edit or delete cards either", () => {
+    // Arrange
+    const observer = { ...owner, isOwner: false };
+    const readOnly = { type: "status" as const, message: "observer - read-only" };
+
+    // Assert
+    expect(resolveThreadChord({ name: "e", meta: true }, observer)).toEqual(readOnly);
+    expect(resolveThreadChord({ name: "backspace", meta: true }, observer)).toEqual(readOnly);
+    expect(resolveThreadChord({ name: "r", meta: true }, observer)).toEqual({ type: "openRename" });
+  });
+});

package/src/thread-chords.ts

@@ -0,0 +1,169 @@
+/**
+ * The session-level chords of the thread view. Letters in the thread view
+ * type a comment, so everything that acts on the session as a whole - submit,
+ * share, edit, the rail - lives on ctrl chords (cmd where the terminal
+ * delivers it). The guided walk is a diff-review mode and has no chord here. Pure: the view reports whether a composer is open, this maps
+ * a key to an intent or to nothing.
+ */
+
+import type { Intent } from "./keymap";
+
+export interface ThreadChordKey {
+  name: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  super?: boolean;
+}
+
+export interface ThreadChordContext {
+  /** A composer owns the keyboard: chords never fire while one is open. */
+  composing: boolean;
+  /** Collaborators annotate only; submit, edit, and share are the owner's. */
+  isOwner: boolean;
+  /** A resolved session has nothing left to submit. */
+  resolved: boolean;
+  /** The rail shows the tree: next / previous move its selection instead of the cards. */
+  treeActive: boolean;
+  /** A diff review: the block chords act on the code row under the caret (reject, fold, walk). */
+  isDiff?: boolean;
+}
+
+/** The diff-review chords: option plus a letter, acting on the caret's row or file. */
+export const DIFF_CHORD_ENTRIES = [
+  { keys: "⌥x / ⌥X", label: "reject the change / the hunk" },
+  { keys: "⌥u", label: "restore the last rejection" },
+  { keys: "⌥c", label: "collapse the file to its band" },
+  { keys: "⌥d", label: "split / stacked (when wide)" },
+  { keys: "⌥k", label: "start the guided walk" },
+] as const;
+
+/** The cheatsheet rows for the chords, in the same order they are resolved. */
+export const THREAD_CHORD_ENTRIES = [
+  { keys: "⌃enter", label: "submit the review" },
+  { keys: "⌃e", label: "edit in $EDITOR" },
+  { keys: "⌃s", label: "share" },
+  { keys: "⌃r", label: "cycle the rail" },
+] as const;
+
+/** The rail and curation chords: option (alt) plus the plan sheet's old letter. */
+export const RAIL_CHORD_ENTRIES = [
+  { keys: "⌥n / ⌥p", label: "next / previous card" },
+  { keys: "⌥e", label: "edit the card" },
+  { keys: "⌥⌫", label: "delete the card" },
+  { keys: "⌥r", label: "rename the author" },
+  { keys: "⌥x", label: "cut the block" },
+  { keys: "⌥u", label: "restore the last cut" },
+  { keys: "⌥w / ⌥s", label: "widen / narrow the rail" },
+] as const;
+
+/** The tree chords: option plus a letter, all on the rail's Tree tab. */
+export const TREE_CHORD_ENTRIES = [
+  { keys: "⌥t", label: "show / hide the tree" },
+  { keys: "⌥n / ⌥p", label: "next / previous entry" },
+  { keys: "⌥g", label: "go to the entry" },
+  { keys: "⌥b", label: "branch off the tip" },
+  { keys: "⌥l", label: "label a checkpoint" },
+  { keys: "⌥f", label: "fork the path" },
+  { keys: "⌥h", label: "fork and hand off" },
+] as const;
+
+export function resolveThreadChord(
+  key: ThreadChordKey,
+  context: ThreadChordContext,
+): Intent | null {
+  if (context.composing) return null;
+  const modified = Boolean(key.ctrl || key.meta || key.super);
+
+  if (!modified) return null;
+  if (key.name === "return" || key.name === "enter") {
+    if (!context.isOwner) return READ_ONLY;
+
+    return context.resolved ? null : { type: "openSubmit" };
+  }
+  if (key.ctrl) return resolveSessionChord(key.name, context);
+  if (key.meta)
+    return (
+      (context.isDiff && resolveDiffChord(key.name, context)) || resolveRailChord(key.name, context)
+    );
+
+  return null;
+}
+
+/** The diff's row and file chords; null lets the rail chords answer the letter. */
+function resolveDiffChord(name: string, context: ThreadChordContext): Intent | null {
+  switch (name) {
+    case "x":
+      return mutating({ type: "rejectChange" }, context);
+    case "X":
+      return mutating({ type: "rejectHunk" }, context);
+    case "c":
+      return { type: "foldFile" };
+    case "d":
+      return { type: "toggleDiffView" };
+    case "k":
+      return context.resolved ? RESOLVED : { type: "walkStart" };
+    default:
+      return null;
+  }
+}
+
+/** The answers a blocked primitive gets - the same words the keymap uses. */
+const READ_ONLY: Intent = { type: "status", message: "observer - read-only" };
+const RESOLVED: Intent = { type: "status", message: "review submitted - read-only" };
+
+/** Editing, deleting, cutting, and restoring change the review: gated by role and by a verdict. */
+function mutating(intent: Intent, context: ThreadChordContext): Intent {
+  if (!context.isOwner) return READ_ONLY;
+  if (context.resolved) return RESOLVED;
+
+  return intent;
+}
+
+function resolveSessionChord(name: string, context: ThreadChordContext): Intent | null {
+  switch (name) {
+    case "e":
+      return mutating({ type: "edit" }, context);
+    case "s":
+      return context.isOwner ? { type: "share" } : READ_ONLY;
+    default:
+      return null;
+  }
+}
+
+// option arrives as meta in this terminal stack; the letters mirror the
+// plan sheet's keymap so the rail keeps its muscle memory
+function resolveRailChord(name: string, context: ThreadChordContext): Intent | null {
+  switch (name) {
+    case "n":
+      return context.treeActive ? { type: "treeMove", direction: 1 } : { type: "nextAnnotation" };
+    case "p":
+      return context.treeActive ? { type: "treeMove", direction: -1 } : { type: "prevAnnotation" };
+    case "t":
+      return { type: "toggleTree" };
+    // the tree is the owner's: a move, a branch, or a label changes what everyone sees
+    case "g":
+      return mutating({ type: "treeGo" }, context);
+    case "b":
+      return mutating({ type: "treeBranch" }, context);
+    case "l":
+      return mutating({ type: "treeLabel" }, context);
+    // a fork can be taken from a resolved review: only the role gates it
+    case "f":
+      return context.isOwner ? { type: "treeFork" } : READ_ONLY;
+    case "h":
+      return context.isOwner ? { type: "treeForkShare" } : READ_ONLY;
+    case "e":
+      return mutating({ type: "editCard" }, context);
+    case "backspace":
+      return mutating({ type: "removeAnnotation" }, context);
+    // renaming an author is a local display choice, open to every role
+    case "r":
+      return { type: "openRename" };
+    case "x":
+      return mutating({ type: "cut" }, context);
+    case "u":
+      return mutating({ type: "restoreCuration" }, context);
+    default:
+      return null;
+  }
+}