@cueloop/client 0.1.0-alpha.65 → 0.1.0-alpha.67

package/src/components/primitives/Tree.stories.tsx

@@ -0,0 +1,124 @@
+import React from "react";
+import { DARK } from "../../theme";
+import type { Story, StoryMeta } from "../story";
+import { Tree } from "./Tree";
+import type { TreeNode } from "./tree-model";
+
+export const meta: StoryMeta = { title: "Primitives/Tree" };
+
+const FILES: TreeNode[] = [
+  {
+    id: "packages",
+    label: "packages",
+    children: [
+      {
+        id: "schema",
+        label: "schema",
+        children: [
+          { id: "schema/types.ts", label: "types.ts", status: "modified" },
+          { id: "schema/tree-model.ts", label: "tree-model.ts", status: "added" },
+        ],
+      },
+      {
+        id: "daemon",
+        label: "daemon",
+        children: [{ id: "daemon/api.ts", label: "api.ts", status: "modified" }],
+      },
+    ],
+  },
+  { id: "README.md", label: "README.md" },
+  { id: "old.ts", label: "old.ts", status: "deleted" },
+];
+
+const DEEP: TreeNode[] = [
+  {
+    id: "src",
+    label: "src",
+    children: [
+      {
+        id: "src/components",
+        label: "components",
+        children: [
+          {
+            id: "src/components/primitives",
+            label: "primitives",
+            children: [
+              { id: "src/components/primitives/Tree.tsx", label: "Tree.tsx", status: "added" },
+            ],
+          },
+        ],
+      },
+    ],
+  },
+];
+
+const PROJECTS: TreeNode[] = [
+  {
+    id: "projects",
+    label: "Projects",
+    children: [
+      {
+        id: "cueloop",
+        label: "cueloop",
+        children: [{ id: "cueloop/read", label: "Read Cueloop Repository" }],
+      },
+    ],
+  },
+  {
+    id: "threads",
+    label: "Threads",
+    children: [{ id: "threads/welcome", label: "Welcome to cueloop" }],
+  },
+];
+
+function Frame({ children }: { children: React.ReactNode }): React.ReactNode {
+  return (
+    <box style={{ width: 40, height: "100%", backgroundColor: DARK.panel, paddingTop: 1 }}>
+      {children}
+    </box>
+  );
+}
+
+export const FileTree: Story = {
+  render: () => (
+    <Frame>
+      <Tree
+        nodes={FILES}
+        expandedIds={new Set(["packages", "schema", "daemon"])}
+        selectedId="schema/tree-model.ts"
+        showStatus
+      />
+    </Frame>
+  ),
+  expectedColors: [DARK.accent, DARK.green, DARK.red],
+  size: { width: 44, height: 16 },
+};
+
+export const FlattenedChain: Story = {
+  render: () => (
+    <Frame>
+      <Tree
+        nodes={DEEP}
+        expandedIds={new Set(["src", "src/components/primitives"])}
+        flattenEmptyDirectories
+        showStatus
+      />
+    </Frame>
+  ),
+  expectedColors: [DARK.green],
+  size: { width: 44, height: 10 },
+};
+
+export const ProjectsThreads: Story = {
+  render: () => (
+    <Frame>
+      <Tree
+        nodes={PROJECTS}
+        expandedIds={new Set(["projects", "cueloop", "threads"])}
+        selectedId="cueloop/read"
+      />
+    </Frame>
+  ),
+  expectedColors: [DARK.accent],
+  size: { width: 44, height: 12 },
+};

package/src/components/primitives/Tree.tsx

@@ -0,0 +1,96 @@
+// OpenTUI renderer for the headless tree-model; the caller owns expansion and selection.
+
+import React from "react";
+import { DARK, type Theme } from "../../theme";
+import { flattenTree, statusMeta, type TreeNode, type TreeTone } from "./tree-model";
+import { NERD_TREE_ICONS, type TreeIcons } from "./icons";
+
+export interface TreeProps {
+  nodes: readonly TreeNode[];
+  expandedIds: ReadonlySet<string>;
+  selectedId?: string;
+  flattenEmptyDirectories?: boolean;
+  showStatus?: boolean;
+  /** Drop the folder/file glyph prefix, for a plain text tree (e.g. the settings nav). */
+  hideIcons?: boolean;
+  indentWidth?: number;
+  icons?: TreeIcons;
+  onSelect?: (id: string) => void;
+  onToggle?: (id: string) => void;
+  theme?: Theme;
+}
+
+function rowGlyph(isFolder: boolean, expanded: boolean, icons: TreeIcons): string {
+  if (!isFolder) return icons.leaf;
+
+  return expanded ? icons.expanded : icons.collapsed;
+}
+
+function toneColor(tone: TreeTone, theme: Theme): string {
+  if (tone === "green") return theme.green;
+  if (tone === "blue") return theme.blue;
+  if (tone === "red") return theme.red;
+
+  return theme.textDim;
+}
+
+export function Tree({
+  nodes,
+  expandedIds,
+  selectedId,
+  flattenEmptyDirectories,
+  showStatus,
+  hideIcons,
+  indentWidth = 2,
+  icons = NERD_TREE_ICONS,
+  onSelect,
+  onToggle,
+  theme,
+}: TreeProps): React.ReactNode {
+  const tokens = theme ?? DARK;
+  const rows = flattenTree(nodes, { expandedIds, flattenEmptyDirectories });
+
+  return (
+    <box style={{ flexDirection: "column" }}>
+      {rows.map((row) => {
+        const selected = row.id === selectedId;
+        const status = showStatus && row.status !== undefined ? statusMeta(row.status) : null;
+        const labelColor = selected
+          ? tokens.text
+          : status
+            ? toneColor(status.tone, tokens)
+            : row.isFolder
+              ? tokens.text
+              : tokens.textMuted;
+
+        return (
+          <box
+            key={row.id}
+            id={`tree-row-${row.id}`}
+            style={{
+              flexDirection: "row",
+              paddingLeft: 1 + row.depth * indentWidth,
+              paddingRight: 1,
+              backgroundColor: selected ? tokens.elevated : undefined,
+            }}
+            onMouseUp={() => (row.isFolder ? onToggle?.(row.id) : onSelect?.(row.id))}
+          >
+            {hideIcons ? null : (
+              <text fg={row.isFolder ? tokens.blue : tokens.textDim}>
+                {row.icon ?? rowGlyph(row.isFolder, row.expanded, icons)}{" "}
+              </text>
+            )}
+            <box style={{ flexShrink: 1, minWidth: 0 }}>
+              <text fg={selected ? tokens.accent : labelColor} truncate>
+                {row.label}
+              </text>
+            </box>
+            <box style={{ flexGrow: 1 }} />
+            {row.badge !== undefined ? <text fg={tokens.textDim}>{row.badge}</text> : null}
+            {status ? <text fg={toneColor(status.tone, tokens)}> {status.letter}</text> : null}
+          </box>
+        );
+      })}
+    </box>
+  );
+}

package/src/components/primitives/icons.ts

@@ -0,0 +1,61 @@
+// Nerd Font glyphs (Private Use Area / codicons) plus the plus-minus diff mark; render as icons under a Nerd Font, tofu without one.
+
+export const NERD = {
+  folderClosed: "",
+  folderOpen: "",
+  file: "",
+  chevronRight: "",
+  chevronDown: "",
+  settings: "",
+  search: "",
+  expand: "",
+  diff: "",
+  copy: "",
+  unfold: "",
+  kebab: "⋮",
+  pin: "⚑",
+  close: "✕",
+  listTree: "",
+  sidebarLeft: "",
+  sidebarLeftOff: "",
+  sidebarRight: "",
+  sidebarRightOff: "",
+  submit: "",
+  zoom: "⛶",
+  split: "",
+} as const;
+
+// The thin rule under each pane header: an overline sits at the top edge of its cell so it hugs the
+// header text (unlike the default light-horizontal, which floats mid-cell); painted in divider gray upstream.
+export const HEADER_UNDERLINE_CHARS = {
+  topLeft: "\u250c",
+  topRight: "\u2510",
+  bottomLeft: "\u2514",
+  bottomRight: "\u2518",
+  horizontal: "\u203e",
+  vertical: "\u2502",
+  topT: "\u252c",
+  bottomT: "\u2534",
+  leftT: "\u251c",
+  rightT: "\u2524",
+  cross: "\u253c",
+} as const;
+
+export interface TreeIcons {
+  collapsed: string;
+  expanded: string;
+  leaf: string;
+}
+
+export const NERD_TREE_ICONS: TreeIcons = {
+  collapsed: NERD.folderClosed,
+  expanded: NERD.folderOpen,
+  leaf: NERD.file,
+};
+
+// Fallback for terminals without a Nerd Font.
+export const ASCII_TREE_ICONS: TreeIcons = {
+  collapsed: "▸",
+  expanded: "▾",
+  leaf: " ",
+};

package/src/components/primitives/tree-model.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test";
+import { allFolderIds, flattenTree, statusMeta, type TreeNode } from "./tree-model";
+
+const TREE: TreeNode[] = [
+  {
+    id: "src",
+    label: "src",
+    children: [
+      { id: "src/a.ts", label: "a.ts", status: "modified" },
+      {
+        id: "src/nested",
+        label: "nested",
+        children: [
+          {
+            id: "src/nested/only",
+            label: "only",
+            children: [{ id: "deep", label: "deep.ts", status: "added" }],
+          },
+        ],
+      },
+    ],
+  },
+  { id: "readme", label: "README.md" },
+];
+
+describe("flattenTree", () => {
+  test("a collapsed folder shows only itself; expanding it reveals its children", () => {
+    // Act
+    const collapsed = flattenTree(TREE, { expandedIds: new Set() });
+    const rows = flattenTree(TREE, { expandedIds: new Set(["src"]) });
+
+    // Assert
+    expect(collapsed.map((row) => row.label)).toEqual(["src", "README.md"]);
+    expect(rows.map((row) => [row.label, row.depth, row.isFolder])).toEqual([
+      ["src", 0, true],
+      ["a.ts", 1, false],
+      ["nested", 1, true],
+      ["README.md", 0, false],
+    ]);
+    expect(rows.find((row) => row.label === "src")!.expanded).toBe(true);
+    expect(rows.find((row) => row.label === "a.ts")!.status).toBe("modified");
+  });
+
+  test("flattenEmptyDirectories collapses a single-subfolder chain into one row", () => {
+    // Act - src open but the chain itself collapsed (none of its ids expanded)
+    const collapsed = flattenTree(TREE, {
+      expandedIds: new Set(["src"]),
+      flattenEmptyDirectories: true,
+    });
+    // Act - expanding via any id along the chain opens it
+    const expanded = flattenTree(TREE, {
+      expandedIds: new Set(["src", "src/nested/only"]),
+      flattenEmptyDirectories: true,
+    });
+
+    // Assert
+    expect(collapsed.map((row) => row.label)).toEqual(["src", "a.ts", "nested/only", "README.md"]);
+    expect(expanded.map((row) => row.label)).toEqual([
+      "src",
+      "a.ts",
+      "nested/only",
+      "deep.ts",
+      "README.md",
+    ]);
+  });
+
+  test("without the flag the chain stays one folder per row", () => {
+    // Act
+    const rows = flattenTree(TREE, {
+      expandedIds: new Set(["src", "src/nested", "src/nested/only"]),
+    });
+
+    // Assert
+    expect(rows.map((row) => [row.label, row.depth])).toEqual([
+      ["src", 0],
+      ["a.ts", 1],
+      ["nested", 1],
+      ["only", 2],
+      ["deep.ts", 3],
+      ["README.md", 0],
+    ]);
+  });
+});
+
+describe("allFolderIds", () => {
+  test("collects every folder, not the leaves", () => {
+    // Assert
+    expect([...allFolderIds(TREE)].sort()).toEqual(["src", "src/nested", "src/nested/only"]);
+  });
+});
+
+describe("statusMeta", () => {
+  test("maps each status to a letter and a tone", () => {
+    // Assert
+    expect(statusMeta("added")).toEqual({ letter: "A", tone: "green" });
+    expect(statusMeta("deleted")).toEqual({ letter: "D", tone: "red" });
+    expect(statusMeta("ignored")).toEqual({ letter: "I", tone: "muted" });
+  });
+});

package/src/components/primitives/tree-model.ts

@@ -0,0 +1,137 @@
+// Headless tree model mirrored from @pierre/trees (DOM-only): share the model, render our own.
+
+export type GitStatus = "added" | "modified" | "deleted" | "renamed" | "untracked" | "ignored";
+
+export interface TreeNode {
+  id: string;
+  label: string;
+  children?: TreeNode[];
+  status?: GitStatus;
+  badge?: string;
+  icon?: string;
+}
+
+export interface FlattenOptions {
+  expandedIds: ReadonlySet<string>;
+  flattenEmptyDirectories?: boolean;
+}
+
+export interface VisibleRow {
+  id: string;
+  label: string;
+  depth: number;
+  isFolder: boolean;
+  expanded: boolean;
+  status?: GitStatus;
+  badge?: string;
+  icon?: string;
+}
+
+function isFolder(node: TreeNode): boolean {
+  return node.children !== undefined;
+}
+
+interface CollapsedChain {
+  label: string;
+  tail: TreeNode;
+  chainIds: string[];
+}
+
+// flattenEmptyDirectories: fold a chain of single-subfolder folders into one row.
+function collapseChain(node: TreeNode): CollapsedChain {
+  let tail = node;
+  const labels = [node.label];
+  const chainIds = [node.id];
+
+  while (tail.children?.length === 1 && isFolder(tail.children[0]!)) {
+    tail = tail.children[0]!;
+    labels.push(tail.label);
+    chainIds.push(tail.id);
+  }
+
+  return { label: labels.join("/"), tail, chainIds };
+}
+
+export function flattenTree(nodes: readonly TreeNode[], options: FlattenOptions): VisibleRow[] {
+  const rows: VisibleRow[] = [];
+  const walk = (list: readonly TreeNode[], depth: number): void => {
+    for (const node of list) {
+      if (!isFolder(node)) {
+        const leaf: VisibleRow = {
+          id: node.id,
+          label: node.label,
+          depth,
+          isFolder: false,
+          expanded: false,
+        };
+
+        if (node.status !== undefined) leaf.status = node.status;
+        if (node.badge !== undefined) leaf.badge = node.badge;
+        if (node.icon !== undefined) leaf.icon = node.icon;
+        rows.push(leaf);
+        continue;
+      }
+      const collapsed = options.flattenEmptyDirectories
+        ? collapseChain(node)
+        : { label: node.label, tail: node, chainIds: [node.id] };
+      // open when any id along a collapsed chain is expanded
+      const expanded = collapsed.chainIds.some((id) => options.expandedIds.has(id));
+      const row: VisibleRow = {
+        id: node.id,
+        label: collapsed.label,
+        depth,
+        isFolder: true,
+        expanded,
+      };
+
+      if (node.badge !== undefined) row.badge = node.badge;
+      if (node.icon !== undefined) row.icon = node.icon;
+      rows.push(row);
+      if (expanded) walk(collapsed.tail.children ?? [], depth + 1);
+    }
+  };
+
+  walk(nodes, 0);
+
+  return rows;
+}
+
+export function allFolderIds(nodes: readonly TreeNode[]): Set<string> {
+  const ids = new Set<string>();
+  const walk = (list: readonly TreeNode[]): void => {
+    for (const node of list) {
+      if (isFolder(node)) {
+        ids.add(node.id);
+        walk(node.children ?? []);
+      }
+    }
+  };
+
+  walk(nodes);
+
+  return ids;
+}
+
+export type TreeTone = "green" | "blue" | "red" | "muted";
+
+export interface StatusMeta {
+  letter: string;
+  tone: TreeTone;
+}
+
+export function statusMeta(status: GitStatus): StatusMeta {
+  switch (status) {
+    case "added":
+      return { letter: "A", tone: "green" };
+    case "modified":
+      return { letter: "M", tone: "blue" };
+    case "deleted":
+      return { letter: "D", tone: "red" };
+    case "renamed":
+      return { letter: "R", tone: "blue" };
+    case "untracked":
+      return { letter: "U", tone: "green" };
+    case "ignored":
+      return { letter: "I", tone: "muted" };
+  }
+}

package/src/components/quick-actions-editor.stories.tsx

@@ -4,7 +4,7 @@ import { DEFAULT_QUICK_ACTIONS } from "../config";
 import type { Story, StoryMeta } from "./story";
 import { QuickActionsEditor } from "./quick-actions-editor";
 
-export const meta: StoryMeta = { title: "QuickActionsEditor" };
+export const meta: StoryMeta = { title: "Chrome/QuickActionsEditor" };
 
 /** The editor renders inside the settings body column. */
 function BodyFrame({ children }: { children: React.ReactNode }): React.ReactNode {

package/src/components/session-tree.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, test } from "bun:test";
+import type { ReviewSession, WorkspaceKey } from "@cueloop/schema";
+import { groupInbox, projectName } from "./session-tree";
+
+function session(id: string, title: string, rootCommit?: string, remote?: string): ReviewSession {
+  const workspace: WorkspaceKey = { repoRoot: `/home/dev/${id}-checkout`, branch: "main" };
+  if (rootCommit !== undefined) workspace.rootCommit = rootCommit;
+  if (remote !== undefined) workspace.remote = remote;
+
+  return {
+    schemaVersion: "1",
+    id,
+    workspace,
+    artifact: { type: "plan", content: `# ${title}\n`, meta: { title } },
+    revisions: [],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
+}
+
+describe("projectName", () => {
+  test("prefers the remote basename and strips the .git suffix", () => {
+    // Arrange
+    const workspace: WorkspaceKey = {
+      repoRoot: "/tmp/whatever",
+      branch: "main",
+      remote: "git@github.com:acme/widget.git",
+    };
+
+    // Act
+    const name = projectName(workspace);
+
+    // Assert
+    expect(name).toBe("widget");
+  });
+
+  test("falls back to the working-tree folder name when there is no remote", () => {
+    // Arrange
+    const workspace: WorkspaceKey = { repoRoot: "/home/dev/cueloop", branch: "main" };
+
+    // Act
+    const name = projectName(workspace);
+
+    // Assert
+    expect(name).toBe("cueloop");
+  });
+});
+
+describe("groupInbox", () => {
+  test("splits repo-bound threads into Projects and the rest into Threads", () => {
+    // Arrange
+    const sessions = [
+      session("a", "Read the repo", "root-1", "git@github.com:acme/widget.git"),
+      session("b", "A loose idea"),
+    ];
+
+    // Act
+    const { rows, ordered } = groupInbox(sessions);
+
+    // Assert
+    const labels = rows.map((row) => `${row.kind}:${"label" in row ? row.label : row.id}`);
+    expect(labels).toEqual([
+      "section:Projects",
+      "project:widget",
+      "thread:a",
+      "section:Threads",
+      "thread:b",
+    ]);
+    expect(ordered.map((s) => s.id)).toEqual(["a", "b"]);
+  });
+
+  test("collapses threads sharing a root commit into one project", () => {
+    // Arrange
+    const sessions = [
+      session("a", "First", "root-1", "git@github.com:acme/widget.git"),
+      session("b", "Second", "root-1", "git@github.com:acme/widget.git"),
+    ];
+
+    // Act
+    const { rows, ordered } = groupInbox(sessions);
+
+    // Assert
+    const projectRows = rows.filter((row) => row.kind === "project");
+    expect(projectRows).toHaveLength(1);
+    expect(ordered).toHaveLength(2);
+  });
+
+  test("selectionIndex on each thread matches its position in ordered", () => {
+    // Arrange
+    const sessions = [session("a", "One", "root-1"), session("b", "Two")];
+
+    // Act
+    const { rows, ordered } = groupInbox(sessions);
+
+    // Assert
+    for (const row of rows) {
+      if (row.kind === "thread") expect(ordered[row.selectionIndex]!.id).toBe(row.id);
+    }
+  });
+
+  test("omits the Projects section when nothing is repo-bound", () => {
+    // Arrange
+    const sessions = [session("a", "Loose one"), session("b", "Loose two")];
+
+    // Act
+    const { rows } = groupInbox(sessions);
+
+    // Assert
+    expect(rows.some((row) => row.kind === "section" && row.label === "Projects")).toBe(false);
+    expect(rows.some((row) => row.kind === "section" && row.label === "Threads")).toBe(true);
+  });
+
+  test("a pinned thread lifts into a Pinned section at the top, out of its normal group", () => {
+    // Arrange - one repo-bound thread, one standalone; pin the repo-bound one
+    const sessions = [session("a", "Pinned one", "root-1"), session("b", "Loose two")];
+
+    // Act
+    const { rows, ordered } = groupInbox(sessions, new Set(["a"]));
+
+    // Assert - Pinned is the first section and holds thread a; a is gone from Projects
+    const sections = rows
+      .filter((row) => row.kind === "section")
+      .map((row) => (row.kind === "section" ? row.label : ""));
+
+    expect(sections[0]).toBe("Pinned");
+    expect(sections).not.toContain("Projects"); // its only member was pinned away
+    expect(ordered[0]!.id).toBe("a"); // the cursor walks pinned threads first
+    const pinnedThreadIds = rows.filter((row) => row.kind === "thread").map((row) => row.id);
+
+    expect(pinnedThreadIds).toEqual(["a", "b"]);
+  });
+});